sentry-ruby 5.26.0 → 6.4.0

data/lib/sentry/configuration.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cgi/escape"
 require "concurrent/utility/processor_counter"
 
 require "sentry/utils/exception_cause_chain"
@@ -9,11 +10,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
@@ -30,13 +32,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
@@ -74,11 +69,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
@@ -88,7 +82,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
@@ -101,6 +95,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|
@@ -117,7 +123,6 @@ module Sentry
     #
     # And if you also use sentry-rails:
     # - :active_support_logger
-    # - :monotonic_active_support_logger
     #
     # @return [Array<Symbol>]
     attr_reader :breadcrumbs_logger
@@ -144,7 +149,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
@@ -173,18 +178,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
@@ -196,17 +189,10 @@ module Sentry
     # @return [Logger]
     attr_accessor :sdk_logger
 
-    # @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
+    # File path for DebugTransport to log events to. If not set, defaults to a temporary file.
+    # This is useful for debugging and testing purposes.
+    # @return [String, nil]
+    attr_accessor :sdk_debug_transport_log_file
 
     # Project directory root for in_app detection. Could be Rails root, etc.
     # Set automatically for Rails.
@@ -249,6 +235,12 @@ module Sentry
     # @return [Boolean]
     attr_accessor :send_default_pii
 
+    # Capture queue time from X-Request-Start header set by reverse proxies.
+    # Works with any Rack app behind Nginx, HAProxy, Heroku router, etc.
+    # Defaults to true.
+    # @return [Boolean]
+    attr_accessor :capture_queue_time
+
     # Allow to skip Sentry emails within rake tasks
     # @return [Boolean]
     attr_accessor :skip_rake_integration
@@ -267,10 +259,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
@@ -289,11 +277,9 @@ module Sentry
     # @return [Boolean]
     attr_accessor :enable_logs
 
-    # 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
+    # Structured logging configuration.
+    # @return [StructuredLoggingConfiguration]
+    attr_reader :structured_logging
 
     # Send diagnostic client reports about dropped events, true by default
     # tries to attach to an existing envelope max once every 30s
@@ -315,6 +301,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
@@ -329,6 +327,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>]
@@ -338,6 +345,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
@@ -366,6 +399,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`"
 
@@ -381,6 +416,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
@@ -390,7 +428,23 @@ module Sentry
 
       # allow extensions to add their hooks to the Configuration class
       def add_post_initialization_callback(&block)
-        post_initialization_callbacks << block
+        callbacks[:initialize][:after] << block
+      end
+
+      def before(event, &block)
+        callbacks[event.to_sym][:before] << block
+      end
+
+      def after(event, &block)
+        callbacks[event.to_sym][:after] << block
+      end
+
+      # @!visibility private
+      def callbacks
+        @callbacks ||= {
+          initialize: { before: [], after: [] },
+          configured: { before: [], after: [] }
+        }
       end
 
       def validations
@@ -434,6 +488,8 @@ module Sentry
     validate :profiles_sample_rate, optional: true, type: :numeric
 
     def initialize
+      run_callbacks(:before, :initialize)
+
       self.app_dirs_pattern = APP_DIRS_PATTERN
       self.debug = Sentry::Utils::EnvHelper.env_to_bool(ENV["SENTRY_DEBUG"])
       self.background_worker_threads = (processor_count / 2.0).ceil
@@ -445,7 +501,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
@@ -463,6 +519,7 @@ module Sentry
       self.enable_backpressure_handling = false
       self.trusted_proxies = []
       self.dsn = ENV["SENTRY_DSN"]
+      self.capture_queue_time = true
 
       spotlight_env = ENV["SENTRY_SPOTLIGHT"]
       spotlight_bool = Sentry::Utils::EnvHelper.env_to_bool(spotlight_env, strict: true)
@@ -470,26 +527,36 @@ 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
+      @structured_logging = StructuredLoggingConfiguration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
-      run_post_initialization_callbacks
-
       self.max_log_events = LogEventBuffer::DEFAULT_MAX_EVENTS
+      self.max_metric_events = MetricEventBuffer::DEFAULT_MAX_METRICS
+
+      run_callbacks(:after, :initialize)
+
+      yield(self) if block_given?
+
+      run_callbacks(:after, :configured)
     end
 
     def validate
@@ -522,22 +589,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)
@@ -563,12 +614,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
@@ -577,15 +646,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)
@@ -641,7 +707,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)
@@ -652,7 +718,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?
@@ -773,8 +839,8 @@ module Sentry
       File.directory?("/etc/heroku") && !ENV["CI"]
     end
 
-    def run_post_initialization_callbacks
-      self.class.post_initialization_callbacks.each do |hook|
+    def run_callbacks(hook, event)
+      self.class.callbacks[event][hook].each do |hook|
         instance_eval(&hook)
       end
     end
@@ -783,5 +849,37 @@ 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
+    # File path for DebugStructuredLogger to log events to
+    # @return [String, Pathname, nil]
+    attr_accessor :file_path
+
+    # The class to use as a structured logger.
+    # @return [Class]
+    attr_accessor :logger_class
+
+    def initialize
+      @file_path = nil
+      @logger_class = Sentry::StructuredLogger
+    end
   end
 end

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/debug_structured_logger.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "pathname"
+require "delegate"
+
+module Sentry
+  # DebugStructuredLogger is a logger that captures structured log events to a file for debugging purposes.
+  #
+  # It can optionally also send log events to Sentry via the normal structured logger if logging
+  # is enabled.
+  class DebugStructuredLogger < SimpleDelegator
+    DEFAULT_LOG_FILE_PATH = File.join("log", "sentry_debug_logs.log")
+
+    attr_reader :log_file, :backend
+
+    def initialize(configuration)
+      @log_file = initialize_log_file(
+        configuration.structured_logging.file_path || DEFAULT_LOG_FILE_PATH
+      )
+      @backend = initialize_backend(configuration)
+
+      super(@backend)
+    end
+
+    # Override all log level methods to capture events
+    %i[trace debug info warn error fatal].each do |level|
+      define_method(level) do |message, parameters = [], **attributes|
+        log_event = capture_log_event(level, message, parameters, **attributes)
+        backend.public_send(level, message, parameters, **attributes)
+        log_event
+      end
+    end
+
+    def log(level, message, parameters:, **attributes)
+      log_event = capture_log_event(level, message, parameters, **attributes)
+      backend.log(level, message, parameters: parameters, **attributes)
+      log_event
+    end
+
+    def capture_log_event(level, message, parameters, **attributes)
+      log_event_json = {
+        timestamp: Time.now.utc.iso8601,
+        level: level.to_s,
+        message: message,
+        parameters: parameters,
+        attributes: attributes
+      }
+
+      File.open(log_file, "a") { |file| file << JSON.dump(log_event_json) << "\n" }
+      log_event_json
+    end
+
+    def logged_events
+      File.readlines(log_file).map do |line|
+        JSON.parse(line)
+      end
+    end
+
+    def clear
+      File.write(log_file, "")
+      if backend.respond_to?(:config)
+        backend.config.sdk_logger.debug("DebugStructuredLogger: Cleared events from #{log_file}")
+      end
+    end
+
+    private
+
+    def initialize_backend(configuration)
+      if configuration.enable_logs
+        StructuredLogger.new(configuration)
+      else
+        # Create a no-op logger if logging is disabled
+        NoOpLogger.new
+      end
+    end
+
+    def initialize_log_file(log_file_path)
+      log_file = Pathname(log_file_path)
+
+      FileUtils.mkdir_p(log_file.dirname) unless log_file.dirname.exist?
+
+      log_file
+    end
+
+    # No-op logger for when structured logging is disabled
+    class NoOpLogger
+      %i[trace debug info warn error fatal log].each do |method|
+        define_method(method) { |*args, **kwargs| nil }
+      end
+    end
+  end
+end

data/lib/sentry/dsn.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 require "uri"
+require "ipaddr"
+require "resolv"
 
 module Sentry
   class DSN
+    PROTOCOL_VERSION = "7"
     PORT_MAP = { "http" => 80, "https" => 443 }.freeze
     REQUIRED_ATTRIBUTES = %w[host path public_key project_id].freeze
+    LOCALHOST_NAMES = %w[localhost 127.0.0.1 ::1 [::1]].freeze
+    LOCALHOST_PATTERN = /\.local(host|domain)?$/i
 
     attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 
@@ -49,5 +54,52 @@ module Sentry
     def envelope_endpoint
       "#{path}/api/#{project_id}/envelope/"
     end
+
+    def otlp_traces_endpoint
+      "#{path}/api/#{project_id}/integration/otlp/v1/traces/"
+    end
+
+    def local?
+      @local ||= (localhost? || private_ip? || resolved_ips_private?)
+    end
+
+    def localhost?
+      LOCALHOST_NAMES.include?(host.downcase) || LOCALHOST_PATTERN.match?(host)
+    end
+
+    def private_ip?
+      @private_ip ||= begin
+        begin
+          IPAddr.new(host).private?
+        rescue IPAddr::InvalidAddressError
+          false
+        end
+      end
+    end
+
+    def resolved_ips_private?
+      @resolved_ips_private ||= begin
+        begin
+          Resolv.getaddresses(host).any? { |ip| IPAddr.new(ip).private? }
+        rescue Resolv::ResolvError, IPAddr::InvalidAddressError
+          false
+        end
+      end
+    end
+
+    def generate_auth_header(client: nil)
+      now = Sentry.utc_now.to_i
+
+      fields = {
+        "sentry_version" => PROTOCOL_VERSION,
+        "sentry_timestamp" => now,
+        "sentry_key" => @public_key
+      }
+
+      fields["sentry_client"] = client if client
+      fields["sentry_secret"] = @secret_key if @secret_key
+
+      "Sentry " + fields.map { |key, value| "#{key}=#{value}" }.join(", ")
+    end
   end
 end