sentry-ruby 5.26.0 → 6.0.0

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,15 @@
 # frozen_string_literal: true
 
 require "uri"
+require "ipaddr"
+require "resolv"
 
 module Sentry
   class DSN
     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 +53,33 @@ module Sentry
     def envelope_endpoint
       "#{path}/api/#{project_id}/envelope/"
     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
   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(
@@ -18,7 +18,6 @@ module Sentry
       when "session", "attachment", "transaction", "profile", "span", "log" then type
       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/graphql.rb

@@ -4,6 +4,6 @@ Sentry.register_patch(:graphql) do |config|
   if defined?(::GraphQL::Schema) && defined?(::GraphQL::Tracing::SentryTrace) && ::GraphQL::Schema.respond_to?(:trace_with)
     ::GraphQL::Schema.trace_with(::GraphQL::Tracing::SentryTrace, set_transaction_name: true)
   else
-    config.logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile." }
+    config.sdk_logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile." }
   end
 end

data/lib/sentry/hub.rb

@@ -116,11 +116,12 @@ 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,
-        parent_sampled: transaction.parent_sampled
+        transaction_context: transaction.to_h,
+        parent_sampled: transaction.parent_sampled,
+        parent_sample_rate: transaction.parent_sample_rate
       }
 
       sampling_context.merge!(custom_sampling_context)
@@ -217,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)
 
@@ -352,11 +353,11 @@ 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,
         baggage: propagation_context.baggage,
+        sample_rand: propagation_context.sample_rand,
         **options
       )
     end

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
 

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
           }
         ]
       }

data/lib/sentry/log_event.rb

@@ -29,9 +29,12 @@ module Sentry
       "sentry.address" => :server_name,
       "sentry.sdk.name" => :sdk_name,
       "sentry.sdk.version" => :sdk_version,
-      "sentry.message.template" => :template
+      "sentry.message.template" => :template,
+      "sentry.origin" => :origin
     }
 
+    PARAMETER_PREFIX = "sentry.message.parameter"
+
     USER_ATTRIBUTES = {
       "user.id" => :user_id,
       "user.name" => :user_username,
@@ -40,9 +43,9 @@ module Sentry
 
     LEVELS = %i[trace debug info warn error fatal].freeze
 
-    attr_accessor :level, :body, :template, :attributes, :user
+    attr_accessor :level, :body, :template, :attributes, :user, :origin
 
-    attr_reader :configuration, *SERIALIZEABLE_ATTRIBUTES
+    attr_reader :configuration, *(SERIALIZEABLE_ATTRIBUTES - %i[level body attributes])
 
     SERIALIZERS = %i[
       attributes
@@ -51,6 +54,7 @@ module Sentry
       parent_span_id
       sdk_name
       sdk_version
+      template
       timestamp
       trace_id
       user_id
@@ -79,10 +83,11 @@ module Sentry
       @template = @body if is_template?
       @attributes = options[:attributes] || DEFAULT_ATTRIBUTES
       @user = options[:user] || {}
+      @origin = options[:origin]
       @contexts = {}
     end
 
-    def to_hash
+    def to_h
       SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
         memo[name] = serialize(name)
       end
@@ -146,6 +151,10 @@ module Sentry
       user[:email]
     end
 
+    def serialize_template
+      template if has_parameters?
+    end
+
     def serialize_attributes
       hash = {}
 
@@ -185,11 +194,11 @@ module Sentry
 
         if parameters.is_a?(Hash)
           parameters.each do |key, value|
-            attributes["sentry.message.parameter.#{key}"] = value
+            attributes["#{PARAMETER_PREFIX}.#{key}"] = value
           end
         else
           parameters.each_with_index do |param, index|
-            attributes["sentry.message.parameter.#{index}"] = param
+            attributes["#{PARAMETER_PREFIX}.#{index}"] = param
           end
         end
       end
@@ -202,5 +211,9 @@ module Sentry
     def is_template?
       body.include?("%s") || TOKEN_REGEXP.match?(body)
     end
+
+    def has_parameters?
+      attributes.keys.any? { |key| key.start_with?(PARAMETER_PREFIX) }
+    end
   end
 end

data/lib/sentry/profiler.rb

@@ -10,8 +10,6 @@ module Sentry
 
     VERSION = "1"
     PLATFORM = "ruby"
-    # 101 Hz in microseconds
-    DEFAULT_INTERVAL = 1e6 / 101
     MICRO_TO_NANO_SECONDS = 1e3
     MIN_SAMPLES_REQUIRED = 2
 
@@ -24,6 +22,7 @@ module Sentry
 
       @profiling_enabled = defined?(StackProf) && configuration.profiling_enabled?
       @profiles_sample_rate = configuration.profiles_sample_rate
+      @profiles_sample_interval = configuration.profiles_sample_interval
       @project_root = configuration.project_root
       @app_dirs_pattern = configuration.app_dirs_pattern
       @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
@@ -32,7 +31,7 @@ module Sentry
     def start
       return unless @sampled
 
-      @started = StackProf.start(interval: DEFAULT_INTERVAL,
+      @started = StackProf.start(interval: @profiles_sample_interval,
                                  mode: :wall,
                                  raw: true,
                                  aggregate: false)
@@ -81,9 +80,9 @@ module Sentry
       log("Discarding profile due to sampling decision") unless @sampled
     end
 
-    def to_hash
+    def to_h
       unless @sampled
-        record_lost_event(:sample_rate)
+        record_lost_event(:sample_rate) if @profiling_enabled
         return {}
       end
 

data/lib/sentry/propagation_context.rb

@@ -3,15 +3,14 @@
 require "securerandom"
 require "sentry/baggage"
 require "sentry/utils/uuid"
+require "sentry/utils/sample_rand"
 
 module Sentry
   class PropagationContext
     SENTRY_TRACE_REGEXP = Regexp.new(
-      "^[ \t]*" +  # whitespace
-      "([0-9a-f]{32})?" +  # trace_id
+      "\\A([0-9a-f]{32})?" + # trace_id
       "-?([0-9a-f]{16})?" +  # span_id
-      "-?([01])?" +  # sampled
-      "[ \t]*$"  # whitespace
+      "-?([01])?\\z"         # sampled
     )
 
     # An uuid that can be used to identify a trace.
@@ -33,6 +32,53 @@ module Sentry
     # Please use the #get_baggage method for interfacing outside this class.
     # @return [Baggage, nil]
     attr_reader :baggage
+    # The propagated random value used for sampling decisions.
+    # @return [Float, nil]
+    attr_reader :sample_rand
+
+    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
+    #
+    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
+    # @return [Array, nil]
+    def self.extract_sentry_trace(sentry_trace)
+      value = sentry_trace.to_s.strip
+      return if value.empty?
+
+      match = SENTRY_TRACE_REGEXP.match(value)
+      return if match.nil?
+
+      trace_id, parent_span_id, sampled_flag = match[1..3]
+      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
+
+      [trace_id, parent_span_id, parent_sampled]
+    end
+
+    def self.extract_sample_rand_from_baggage(baggage, trace_id = nil)
+      return unless baggage&.items
+
+      sample_rand_str = baggage.items["sample_rand"]
+      return unless sample_rand_str
+
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+      generator.generate_from_value(sample_rand_str)
+    end
+
+    def self.generate_sample_rand(baggage, trace_id, parent_sampled)
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+
+      if baggage&.items && !parent_sampled.nil?
+        sample_rate_str = baggage.items["sample_rate"]
+        sample_rate = sample_rate_str&.to_f
+
+        if sample_rate && !parent_sampled.nil?
+          generator.generate_from_sampling_decision(parent_sampled, sample_rate)
+        else
+          generator.generate_from_trace_id
+        end
+      else
+        generator.generate_from_trace_id
+      end
+    end
 
     def initialize(scope, env = nil)
       @scope = scope
@@ -40,6 +86,7 @@ module Sentry
       @parent_sampled = nil
       @baggage = nil
       @incoming_trace = false
+      @sample_rand = nil
 
       if env
         sentry_trace_header = env["HTTP_SENTRY_TRACE"] || env[SENTRY_TRACE_HEADER_NAME]
@@ -61,6 +108,8 @@ module Sentry
                 Baggage.new({})
               end
 
+            @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
+
             @baggage.freeze!
             @incoming_trace = true
           end
@@ -69,20 +118,7 @@ module Sentry
 
       @trace_id ||= Utils.uuid
       @span_id = Utils.uuid.slice(0, 16)
-    end
-
-    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
-    #
-    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
-    # @return [Array, nil]
-    def self.extract_sentry_trace(sentry_trace)
-      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
-      return nil if match.nil?
-
-      trace_id, parent_span_id, sampled_flag = match[1..3]
-      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
-
-      [trace_id, parent_span_id, parent_sampled]
+      @sample_rand ||= self.class.generate_sample_rand(@baggage, @trace_id, @parent_sampled)
     end
 
     # Returns the trace context that can be used to embed in an Event.
@@ -123,6 +159,7 @@ module Sentry
 
       items = {
         "trace_id" => trace_id,
+        "sample_rand" => Utils::SampleRand.format(@sample_rand),
         "environment" => configuration.environment,
         "release" => configuration.release,
         "public_key" => configuration.dsn&.public_key

data/lib/sentry/rspec.rb

@@ -70,7 +70,7 @@ RSpec::Matchers.define :include_sentry_event do |event_message = "", **opts|
   end
 
   def dump_events(sentry_events)
-    sentry_events.map(&Kernel.method(:Hash)).map do |hash|
+    sentry_events.map(&:to_h).map do |hash|
       hash.select { |k, _| [:message, :contexts, :tags, :exception].include?(k) }
     end.map do |hash|
       JSON.pretty_generate(hash)