sentry-ruby 5.28.1 → 6.3.1

data/lib/sentry/configuration.rb

@@ -9,12 +9,12 @@ require "sentry/dsn"
 require "sentry/release_detector"
 require "sentry/transport/configuration"
 require "sentry/cron/configuration"
-require "sentry/metrics/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
 require "sentry/logger"
 require "sentry/structured_logger"
 require "sentry/log_event_buffer"
+require "sentry/metric_event_buffer"
 
 module Sentry
   class Configuration
@@ -31,13 +31,6 @@ module Sentry
     # @return [Regexp, nil]
     attr_accessor :app_dirs_pattern
 
-    # Provide an object that responds to `call` to send events asynchronously.
-    # E.g.: lambda { |event| Thread.new { Sentry.send_event(event) } }
-    #
-    # @deprecated It will be removed in the next major release. Please read https://github.com/getsentry/sentry-ruby/issues/1522 for more information
-    # @return [Proc, nil]
-    attr_reader :async
-
     # to send events in a non-blocking way, sentry-ruby has its own background worker
     # by default, the worker holds a thread pool that has [the number of processors] threads
     # but you can configure it with this configuration option
@@ -75,11 +68,10 @@ module Sentry
     # @return [Proc]
     attr_reader :before_breadcrumb
 
-    # Optional Proc, called before sending an event to the server
+    # Optional Proc, called before sending an error event to the server
     # @example
     #   config.before_send = lambda do |event, hint|
     #     # skip ZeroDivisionError exceptions
-    #     # note: hint[:exception] would be a String if you use async callback
     #     if hint[:exception].is_a?(ZeroDivisionError)
     #       nil
     #     else
@@ -89,7 +81,7 @@ module Sentry
     # @return [Proc]
     attr_reader :before_send
 
-    # Optional Proc, called before sending an event to the server
+    # Optional Proc, called before sending a transaction event to the server
     # @example
     #   config.before_send_transaction = lambda do |event, hint|
     #     # skip unimportant transactions or strip sensitive data
@@ -102,6 +94,18 @@ module Sentry
     # @return [Proc]
     attr_reader :before_send_transaction
 
+    # Optional Proc, called before sending a check-in event to the server
+    # @example
+    #   config.before_send_check_in = lambda do |event, hint|
+    #     if event.monitor_slug == "unimportant_job"
+    #       nil
+    #     else
+    #       event
+    #     end
+    #   end
+    # @return [Proc]
+    attr_reader :before_send_check_in
+
     # Optional Proc, called before sending an event to the server
     # @example
     #   config.before_send_log = lambda do |log|
@@ -118,7 +122,6 @@ module Sentry
     #
     # And if you also use sentry-rails:
     # - :active_support_logger
-    # - :monotonic_active_support_logger
     #
     # @return [Array<Symbol>]
     attr_reader :breadcrumbs_logger
@@ -145,7 +148,7 @@ module Sentry
     attr_reader :dsn
 
     # Whitelist of enabled_environments that will send notifications to Sentry. Array of Strings.
-    # @return [Array<String>]
+    # @return [Array<String>, nil]
     attr_accessor :enabled_environments
 
     # Logger 'progname's to exclude from breadcrumbs
@@ -174,18 +177,6 @@ module Sentry
     # @return [Boolean, String]
     attr_accessor :spotlight
 
-    # @deprecated Use {#include_local_variables} instead.
-    alias_method :capture_exception_frame_locals, :include_local_variables
-
-    # @deprecated Use {#include_local_variables=} instead.
-    def capture_exception_frame_locals=(value)
-      log_warn <<~MSG
-        `capture_exception_frame_locals` is now deprecated in favor of `include_local_variables`.
-      MSG
-
-      self.include_local_variables = value
-    end
-
     # You may provide your own LineCache for matching paths with source files.
     # This may be useful if you need to get source code from places other than the disk.
     # @see LineCache
@@ -202,18 +193,6 @@ module Sentry
     # @return [String, nil]
     attr_accessor :sdk_debug_transport_log_file
 
-    # @deprecated Use {#sdk_logger=} instead.
-    def logger=(logger)
-      warn "[sentry] `config.logger=` is deprecated. Please use `config.sdk_logger=` instead."
-      self.sdk_logger = logger
-    end
-
-    # @deprecated Use {#sdk_logger} instead.
-    def logger
-      warn "[sentry] `config.logger` is deprecated. Please use `config.sdk_logger` instead."
-      self.sdk_logger
-    end
-
     # Project directory root for in_app detection. Could be Rails root, etc.
     # Set automatically for Rails.
     # @return [String]
@@ -273,10 +252,6 @@ module Sentry
     # @return [Cron::Configuration]
     attr_reader :cron
 
-    # Metrics related configuration.
-    # @return [Metrics::Configuration]
-    attr_reader :metrics
-
     # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
     # @return [Float, nil]
     attr_reader :traces_sample_rate
@@ -299,12 +274,6 @@ module Sentry
     # @return [StructuredLoggingConfiguration]
     attr_reader :structured_logging
 
-    # Easier way to use performance tracing
-    # If set to true, will set traces_sample_rate to 1.0
-    # @deprecated It will be removed in the next major release.
-    # @return [Boolean, nil]
-    attr_reader :enable_tracing
-
     # Send diagnostic client reports about dropped events, true by default
     # tries to attach to an existing envelope max once every 30s
     # @return [Boolean]
@@ -325,6 +294,18 @@ module Sentry
     # @return [Array<String, Regexp>]
     attr_accessor :trace_propagation_targets
 
+    # Collection of HTTP status codes or ranges of codes to ignore when tracing incoming requests.
+    # If a transaction's http.response.status_code matches one of these values,
+    # the transaction will be dropped and marked as not sampled.
+    # Defaults to TRACE_IGNORE_STATUS_CODES_DEFAULT.
+    #
+    # @example
+    #   # ignore 404 and 502 <= status_code <= 511
+    #   config.trace_ignore_status_codes = [404, (502..511)]
+    #
+    # @return [Array<Integer>, Array<Range>]
+    attr_reader :trace_ignore_status_codes
+
     # The instrumenter to use, :sentry or :otel
     # @return [Symbol]
     attr_reader :instrumenter
@@ -339,6 +320,15 @@ module Sentry
     # @return [Float, nil]
     attr_reader :profiles_sample_rate
 
+    # Interval in microseconds at which to take samples.
+    # The default is 1e6 / 101, or 101Hz.
+    # Note that the 101 is intentional to avoid lockstep sampling.
+    #
+    # @example
+    #   config.profiles_sample_interval = 1e5 / 101
+    # @return [Float]
+    attr_accessor :profiles_sample_interval
+
     # Array of patches to apply.
     # Default is {DEFAULT_PATCHES}
     # @return [Array<Symbol>]
@@ -348,6 +338,32 @@ module Sentry
     # @return [Integer]
     attr_accessor :max_log_events
 
+    # Enable metrics collection, defaults to true
+    # @return [Boolean]
+    attr_accessor :enable_metrics
+
+    # Maximum number of metric events to buffer before sending
+    # @return [Integer]
+    attr_accessor :max_metric_events
+
+    # Optional Proc, called before sending a metric
+    # @example
+    #   config.before_send_metric = lambda do |metric|
+    #     # return nil to drop the metric
+    #     metric
+    #   end
+    # @return [Proc, nil]
+    attr_reader :before_send_metric
+
+    # Optional Proc, called to filter log messages before sending to Sentry
+    # @example
+    #   config.std_lib_logger_filter = lambda do |logger, message, level|
+    #     # Only send error and fatal logs to Sentry
+    #     [:error, :fatal].include?(level)
+    #   end
+    # @return [Proc, nil]
+    attr_reader :std_lib_logger_filter
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -376,6 +392,8 @@ module Sentry
       SERVER_PORT
     ].freeze
 
+    TRACE_IGNORE_STATUS_CODES_DEFAULT = [(301..303), (305..399), (401..404)]
+
     HEROKU_DYNO_METADATA_MESSAGE = "You are running on Heroku but haven't enabled Dyno Metadata. For Sentry's "\
     "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`"
 
@@ -391,6 +409,9 @@ module Sentry
 
     APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test|spec)/
 
+    # 101 Hz in microseconds
+    DEFAULT_PROFILES_SAMPLE_INTERVAL = 1e6 / 101
+
     class << self
       # Post initialization callbacks are called at the end of initialization process
       # allowing extending the configuration of sentry-ruby by multiple extensions
@@ -473,7 +494,7 @@ module Sentry
       self.context_lines = 3
       self.include_local_variables = false
       self.environment = environment_from_env
-      self.enabled_environments = []
+      self.enabled_environments = nil
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT + PUMA_IGNORE_DEFAULT
       self.inspect_exception_causes_for_exclusion = true
@@ -498,25 +519,30 @@ module Sentry
       self.server_name = server_name_from_env
       self.instrumenter = :sentry
       self.trace_propagation_targets = [PROPAGATION_TARGETS_MATCH_ALL]
+      self.trace_ignore_status_codes = TRACE_IGNORE_STATUS_CODES_DEFAULT
       self.enabled_patches = DEFAULT_PATCHES.dup
 
       self.before_send = nil
       self.before_send_transaction = nil
+      self.before_send_check_in = nil
       self.before_send_log = nil
+      self.before_send_metric = nil
+      self.std_lib_logger_filter = nil
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
       self.traces_sampler = nil
-      self.enable_tracing = nil
       self.enable_logs = false
+      self.enable_metrics = true
 
       self.profiler_class = Sentry::Profiler
+      self.profiles_sample_interval = DEFAULT_PROFILES_SAMPLE_INTERVAL
 
       @transport = Transport::Configuration.new
       @cron = Cron::Configuration.new
-      @metrics = Metrics::Configuration.new(self.sdk_logger)
       @structured_logging = StructuredLoggingConfiguration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       self.max_log_events = LogEventBuffer::DEFAULT_MAX_EVENTS
+      self.max_metric_events = MetricEventBuffer::DEFAULT_MAX_METRICS
 
       run_callbacks(:after, :initialize)
 
@@ -555,22 +581,6 @@ module Sentry
       @release = value
     end
 
-    def async=(value)
-      check_callable!("async", value)
-
-      log_warn <<~MSG
-
-        sentry-ruby now sends events asynchronously by default with its background worker (supported since 4.1.0).
-        The `config.async` callback has become redundant while continuing to cause issues.
-        (The problems of `async` are detailed in https://github.com/getsentry/sentry-ruby/issues/1522)
-
-        Therefore, we encourage you to remove it and let the background worker take care of async job sending.
-      It's deprecation is planned in the next major release (6.0), which is scheduled around the 3rd quarter of 2022.
-      MSG
-
-      @async = value
-    end
-
     def breadcrumbs_logger=(logger)
       loggers =
         if logger.is_a?(Array)
@@ -596,12 +606,30 @@ module Sentry
       @before_send_transaction = value
     end
 
+    def before_send_check_in=(value)
+      check_callable!("before_send_check_in", value)
+
+      @before_send_check_in = value
+    end
+
+    def before_send_metric=(value)
+      check_callable!("before_send_metric", value)
+
+      @before_send_metric = value
+    end
+
     def before_breadcrumb=(value)
       check_callable!("before_breadcrumb", value)
 
       @before_breadcrumb = value
     end
 
+    def std_lib_logger_filter=(value)
+      check_callable!("std_lib_logger_filter", value)
+
+      @std_lib_logger_filter = value
+    end
+
     def environment=(environment)
       @environment = environment.to_s
     end
@@ -610,15 +638,12 @@ module Sentry
       @instrumenter = INSTRUMENTERS.include?(instrumenter) ? instrumenter : :sentry
     end
 
-    def enable_tracing=(enable_tracing)
-      unless enable_tracing.nil?
-        log_warn <<~MSG
-          `enable_tracing` is now deprecated in favor of `traces_sample_rate = 1.0`.
-        MSG
+    def trace_ignore_status_codes=(codes)
+      unless codes.is_a?(Array) && codes.all? { |code| valid_status_code_entry?(code) }
+        raise ArgumentError, "trace_ignore_status_codes must be an Array of integers or ranges between (100-599) where begin <= end"
       end
 
-      @enable_tracing = enable_tracing
-      @traces_sample_rate ||= 1.0 if enable_tracing
+      @trace_ignore_status_codes = codes
     end
 
     def traces_sample_rate=(traces_sample_rate)
@@ -674,7 +699,7 @@ module Sentry
     end
 
     def enabled_in_current_env?
-      enabled_environments.empty? || enabled_environments.include?(environment)
+      enabled_environments.nil? || enabled_environments.include?(environment)
     end
 
     def valid_sample_rate?(sample_rate)
@@ -685,7 +710,7 @@ module Sentry
     def tracing_enabled?
       valid_sampler = !!((valid_sample_rate?(@traces_sample_rate)) || @traces_sampler)
 
-      (@enable_tracing != false) && valid_sampler && sending_allowed?
+      valid_sampler && sending_allowed?
     end
 
     def profiling_enabled?
@@ -816,6 +841,23 @@ module Sentry
       available_processor_count = Concurrent.available_processor_count if Concurrent.respond_to?(:available_processor_count)
       available_processor_count || Concurrent.processor_count
     end
+
+    def valid_http_status_code?(code)
+      code.is_a?(Integer) && code >= 100 && code <= 599
+    end
+
+    def valid_status_code_entry?(entry)
+      case entry
+      when Integer
+        valid_http_status_code?(entry)
+      when Range
+        valid_http_status_code?(entry.begin) &&
+          valid_http_status_code?(entry.end) &&
+          entry.begin <= entry.end
+      else
+        false
+      end
+    end
   end
 
   class StructuredLoggingConfiguration

data/lib/sentry/cron/monitor_check_ins.rb

@@ -14,12 +14,12 @@ module Sentry
                                                 :in_progress,
                                                 monitor_config: monitor_config)
 
-          start = Metrics::Timing.duration_start
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
           begin
             # need to do this on ruby <= 2.6 sadly
             ret = method(:perform).super_method.arity == 0 ? super() : super
-            duration = Metrics::Timing.duration_end(start)
+            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
             Sentry.capture_check_in(slug,
                                     :ok,
@@ -29,7 +29,7 @@ module Sentry
 
             ret
           rescue Exception
-            duration = Metrics::Timing.duration_end(start)
+            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
             Sentry.capture_check_in(slug,
                                     :error,

data/lib/sentry/cron/monitor_config.rb

@@ -40,9 +40,9 @@ module Sentry
         new(MonitorSchedule::Interval.new(num, unit), **options)
       end
 
-      def to_hash
+      def to_h
         {
-          schedule: schedule.to_hash,
+          schedule: schedule.to_h,
           checkin_margin: checkin_margin,
           max_runtime: max_runtime,
           timezone: timezone

data/lib/sentry/cron/monitor_schedule.rb

@@ -12,7 +12,7 @@ module Sentry
           @value = value
         end
 
-        def to_hash
+        def to_h
           { type: :crontab, value: value }
         end
       end
@@ -33,7 +33,7 @@ module Sentry
           @unit = unit
         end
 
-        def to_hash
+        def to_h
           { type: :interval, value: value, unit: unit }
         end
       end

data/lib/sentry/envelope/item.rb

@@ -3,7 +3,7 @@
 module Sentry
   # @api private
   class Envelope::Item
-    STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
+    STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 1000
     MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
 
     SIZE_LIMITS = Hash.new(MAX_SERIALIZED_PAYLOAD_SIZE).update(
@@ -15,10 +15,10 @@ module Sentry
     # rate limits and client reports use the data_category rather than envelope item type
     def self.data_category(type)
       case type
-      when "session", "attachment", "transaction", "profile", "span", "log" then type
+      when "session", "attachment", "transaction", "profile", "span", "trace_metric" then type
+      when "log" then "log_item"
       when "sessions" then "session"
       when "check_in" then "monitor"
-      when "statsd", "metric_meta" then "metric_bucket"
       when "event" then "error"
       when "client_report" then "internal"
       else "default"

data/lib/sentry/error_event.rb

@@ -10,10 +10,10 @@ module Sentry
     attr_reader :threads
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = super
-      data[:threads] = threads.to_hash if threads
-      data[:exception] = exception.to_hash if exception
+      data[:threads] = threads.to_h if threads
+      data[:exception] = exception.to_h if exception
       data
     end
 

data/lib/sentry/event.rb

@@ -81,12 +81,6 @@ module Sentry
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
     end
 
-    # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
-    # @return [Configuration]
-    def configuration
-      Sentry.configuration
-    end
-
     # Sets the event's timestamp.
     # @param time [Time, Float]
     # @return [void]
@@ -118,16 +112,16 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = serialize_attributes
-      data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:request] = request.to_hash if request
+      data[:breadcrumbs] = breadcrumbs.to_h if breadcrumbs
+      data[:request] = request.to_h if request
       data
     end
 
     # @return [Hash]
     def to_json_compatible
-      JSON.parse(JSON.generate(to_hash))
+      JSON.parse(JSON.generate(to_h))
     end
 
     private

data/lib/sentry/hub.rb

@@ -116,10 +116,10 @@ module Sentry
       return unless configuration.tracing_enabled?
       return unless instrumenter == configuration.instrumenter
 
-      transaction ||= Transaction.new(**options.merge(hub: self))
+      transaction ||= Transaction.new(**options)
 
       sampling_context = {
-        transaction_context: transaction.to_hash,
+        transaction_context: transaction.to_h,
         parent_sampled: transaction.parent_sampled,
         parent_sample_rate: transaction.parent_sample_rate
       }
@@ -218,7 +218,7 @@ module Sentry
     end
 
     def capture_log_event(message, **options)
-      return unless current_client
+      return unless current_client && current_client.configuration.enable_logs
 
       event = current_client.event_from_log(message, **options)
 
@@ -227,6 +227,29 @@ module Sentry
       current_client.buffer_log_event(event, current_scope)
     end
 
+    # Captures a metric and sends it to Sentry
+    #
+    # @param name [String] the metric name
+    # @param type [Symbol] the metric type (:counter, :gauge, :distribution)
+    # @param value [Numeric] the metric value
+    # @param unit [String, nil] (optional) the metric unit
+    # @param attributes [Hash, nil] (optional) additional attributes for the metric
+    # @return [void]
+    def capture_metric(name:, type:, value:, unit: nil, attributes: nil)
+      return unless current_client&.configuration.enable_metrics
+
+      metric = MetricEvent.new(
+        name: name,
+        value: value,
+        type: type,
+        unit: unit,
+        attributes: attributes,
+      )
+
+      current_client.buffer_metric_event(metric, current_scope)
+    end
+
+
     def capture_event(event, **options, &block)
       check_argument_type!(event, Sentry::Event)
 
@@ -353,7 +376,6 @@ module Sentry
       return nil unless propagation_context.incoming_trace
 
       Transaction.new(
-        hub: self,
         trace_id: propagation_context.trace_id,
         parent_span_id: propagation_context.parent_span_id,
         parent_sampled: propagation_context.parent_sampled,

data/lib/sentry/interface.rb

@@ -3,7 +3,7 @@
 module Sentry
   class Interface
     # @return [Hash]
-    def to_hash
+    def to_h
       Hash[instance_variables.map { |name| [name[1..-1].to_sym, instance_variable_get(name)] }]
     end
   end

data/lib/sentry/interfaces/exception.rb

@@ -13,9 +13,9 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = super
-      data[:values] = data[:values].map(&:to_hash) if data[:values]
+      data[:values] = data[:values].map(&:to_h) if data[:values]
       data
     end
 

data/lib/sentry/interfaces/request.rb

@@ -69,6 +69,8 @@ module Sentry
     private
 
     def read_data_from(request)
+      return "Skipped non-rewindable request body" unless request.body.respond_to?(:rewind)
+
       if request.form_data?
         request.POST
       elsif request.body # JSON requests, etc

data/lib/sentry/interfaces/single_exception.rb

@@ -32,10 +32,10 @@ module Sentry
       @mechanism = mechanism
     end
 
-    def to_hash
+    def to_h
       data = super
-      data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
-      data[:mechanism] = data[:mechanism].to_hash
+      data[:stacktrace] = data[:stacktrace].to_h if data[:stacktrace]
+      data[:mechanism] = data[:mechanism].to_h
       data
     end
 
@@ -60,7 +60,7 @@ module Sentry
             end
         end
 
-        stacktrace.frames.last.vars = locals
+        stacktrace.frames.last&.vars = locals
       end
 
       new(exception: exception, stacktrace: stacktrace, mechanism: mechanism)

data/lib/sentry/interfaces/stacktrace.rb

@@ -11,8 +11,8 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
-      { frames: @frames.map(&:to_hash) }
+    def to_h
+      { frames: @frames.map(&:to_h) }
     end
 
     # @return [String]
@@ -66,7 +66,7 @@ module Sentry
             linecache.get_file_context(abs_path, lineno, context_lines)
       end
 
-      def to_hash(*args)
+      def to_h(*args)
         data = super(*args)
         data.delete(:vars) unless vars && !vars.empty?
         data.delete(:pre_context) unless pre_context && !pre_context.empty?

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -75,14 +75,6 @@ module Sentry
       StacktraceInterface.new(frames: frames)
     end
 
-    # Get the code location hash for a single line for where metrics where added.
-    # @return [Hash]
-    def metrics_code_location(unparsed_line)
-      parsed_line = Backtrace::Line.parse(unparsed_line)
-      frame = convert_parsed_line_into_frame(parsed_line)
-      frame.to_hash.reject { |k, _| %i[project_root in_app].include?(k) }
-    end
-
     private
 
     def convert_parsed_line_into_frame(line)

data/lib/sentry/interfaces/threads.rb

@@ -13,7 +13,7 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       {
         values: [
           {
@@ -21,7 +21,7 @@ module Sentry
             name: @name,
             crashed: @crashed,
             current: @current,
-            stacktrace: @stacktrace&.to_hash
+            stacktrace: @stacktrace&.to_h
           }
         ]
       }