sentry-ruby 5.10.0 → 5.26.0

data/lib/sentry/transport.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 require "json"
-require "base64"
 require "sentry/envelope"
 
 module Sentry
   class Transport
-    PROTOCOL_VERSION = '7'
+    PROTOCOL_VERSION = "7"
     USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
     CLIENT_REPORT_INTERVAL = 30
 
@@ -18,18 +17,17 @@ module Sentry
       :network_error,
       :sample_rate,
       :before_send,
-      :event_processor
+      :event_processor,
+      :insufficient_data,
+      :backpressure
     ]
 
     include LoggingHelper
 
     attr_reader :rate_limits, :discarded_events, :last_client_report_sent
 
-    # @deprecated Use Sentry.logger to retrieve the current logger instead.
-    attr_reader :logger
-
     def initialize(configuration)
-      @logger = configuration.logger
+      @sdk_logger = configuration.sdk_logger
       @transport_configuration = configuration.transport
       @dsn = configuration.dsn
       @rate_limits = {}
@@ -60,7 +58,7 @@ module Sentry
       data, serialized_items = serialize_envelope(envelope)
 
       if data
-        log_info("[Transport] Sending envelope with items [#{serialized_items.map(&:type).join(', ')}] #{envelope.event_id} to Sentry")
+        log_debug("[Transport] Sending envelope with items [#{serialized_items.map(&:type).join(', ')}] #{envelope.event_id} to Sentry")
         send_data(data)
       end
     end
@@ -73,7 +71,7 @@ module Sentry
         result, oversized = item.serialize
 
         if oversized
-          log_info("Envelope item [#{item.type}] is still oversized after size reduction: {#{item.size_breakdown}}")
+          log_debug("Envelope item [#{item.type}] is still oversized after size reduction: {#{item.size_breakdown}}")
 
           next
         end
@@ -87,18 +85,9 @@ module Sentry
       [data, serialized_items]
     end
 
-    def is_rate_limited?(item_type)
+    def is_rate_limited?(data_category)
       # check category-specific limit
-      category_delay =
-        case item_type
-        when "transaction"
-          @rate_limits["transaction"]
-        when "sessions"
-          @rate_limits["session"]
-        else
-          @rate_limits["error"]
-        end
-
+      category_delay = @rate_limits[data_category]
       # check universal limit if not category limit
       universal_delay = @rate_limits[nil]
 
@@ -118,16 +107,8 @@ module Sentry
       !!delay && delay > Time.now
     end
 
-    def generate_auth_header
-      now = Sentry.utc_now.to_i
-      fields = {
-        'sentry_version' => PROTOCOL_VERSION,
-        'sentry_client' => USER_AGENT,
-        'sentry_timestamp' => now,
-        'sentry_key' => @dsn.public_key
-      }
-      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
-      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    def any_rate_limited?
+      @rate_limits.values.any? { |t| t && t > Time.now }
     end
 
     def envelope_from_event(event)
@@ -143,54 +124,76 @@ module Sentry
         sent_at: Sentry.utc_now.iso8601
       }
 
-      if event.is_a?(TransactionEvent) && event.dynamic_sampling_context
+      if event.is_a?(Event) && event.dynamic_sampling_context
         envelope_headers[:trace] = event.dynamic_sampling_context
       end
 
       envelope = Envelope.new(envelope_headers)
 
-      envelope.add_item(
-        { type: item_type, content_type: 'application/json' },
-        event_payload
-      )
+      if event.is_a?(LogEvent)
+        envelope.add_item(
+          {
+            type: "log",
+            item_count: 1,
+            content_type: "application/vnd.sentry.items.log+json"
+          },
+          { items: [event_payload] }
+        )
+      else
+        envelope.add_item(
+          { type: item_type, content_type: "application/json" },
+          event_payload
+        )
+      end
 
       if event.is_a?(TransactionEvent) && event.profile
         envelope.add_item(
-          { type: 'profile', content_type: 'application/json' },
+          { type: "profile", content_type: "application/json" },
           event.profile
         )
       end
 
+      if event.is_a?(Event) && event.attachments.any?
+        event.attachments.each do |attachment|
+          envelope.add_item(attachment.to_envelope_headers, attachment.payload)
+        end
+      end
+
       client_report_headers, client_report_payload = fetch_pending_client_report
       envelope.add_item(client_report_headers, client_report_payload) if client_report_headers
 
       envelope
     end
 
-    def record_lost_event(reason, item_type)
+    def record_lost_event(reason, data_category, num: 1)
       return unless @send_client_reports
       return unless CLIENT_REPORT_REASONS.include?(reason)
 
-      @discarded_events[[reason, item_type]] += 1
+      @discarded_events[[reason, data_category]] += num
+    end
+
+    def flush
+      client_report_headers, client_report_payload = fetch_pending_client_report(force: true)
+      return unless client_report_headers
+
+      envelope = Envelope.new
+      envelope.add_item(client_report_headers, client_report_payload)
+      send_envelope(envelope)
     end
 
     private
 
-    def fetch_pending_client_report
+    def fetch_pending_client_report(force: false)
       return nil unless @send_client_reports
-      return nil if @last_client_report_sent > Time.now - CLIENT_REPORT_INTERVAL
+      return nil if !force && @last_client_report_sent > Time.now - CLIENT_REPORT_INTERVAL
       return nil if @discarded_events.empty?
 
       discarded_events_hash = @discarded_events.map do |key, val|
-        reason, type = key
-
-        # 'event' has to be mapped to 'error'
-        category = type == 'transaction' ? 'transaction' : 'error'
-
+        reason, category = key
         { reason: reason, category: category, quantity: val }
       end
 
-      item_header = { type: 'client_report' }
+      item_header = { type: "client_report" }
       item_payload = {
         timestamp: Sentry.utc_now.iso8601,
         discarded_events: discarded_events_hash
@@ -204,9 +207,9 @@ module Sentry
 
     def reject_rate_limited_items(envelope)
       envelope.items.reject! do |item|
-        if is_rate_limited?(item.type)
-          log_info("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
-          record_lost_event(:ratelimit_backoff, item.type)
+        if is_rate_limited?(item.data_category)
+          log_debug("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
+          record_lost_event(:ratelimit_backoff, item.data_category)
 
           true
         else
@@ -219,3 +222,4 @@ end
 
 require "sentry/transport/dummy_transport"
 require "sentry/transport/http_transport"
+require "sentry/transport/spotlight_transport"

data/lib/sentry/utils/argument_checking_helper.rb

@@ -9,5 +9,17 @@ module Sentry
         raise ArgumentError, "expect the argument to be a #{expected_types.join(' or ')}, got #{argument.class} (#{argument.inspect})"
       end
     end
+
+    def check_argument_includes!(argument, values)
+      unless values.include?(argument)
+        raise ArgumentError, "expect the argument to be one of #{values.map(&:inspect).join(' or ')}, got #{argument.inspect}"
+      end
+    end
+
+    def check_callable!(name, value)
+      unless value == nil || value.respond_to?(:call)
+        raise ArgumentError, "#{name} must be callable (or nil to disable)"
+      end
+    end
   end
 end

data/lib/sentry/utils/env_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    module EnvHelper
+      TRUTHY_ENV_VALUES = %w[t true yes y 1 on].freeze
+      FALSY_ENV_VALUES = %w[f false no n 0 off].freeze
+
+      def self.env_to_bool(value, strict: false)
+        value = value.to_s
+        normalized = value.downcase
+
+        return false if FALSY_ENV_VALUES.include?(normalized)
+
+        return true if TRUTHY_ENV_VALUES.include?(normalized)
+
+        strict ? nil : !(value.nil? || value.empty?)
+      end
+    end
+  end
+end

data/lib/sentry/utils/http_tracing.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    module HttpTracing
+      def set_span_info(sentry_span, request_info, response_status)
+        sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
+        sentry_span.set_data(Span::DataConventions::URL, request_info[:url])
+        sentry_span.set_data(Span::DataConventions::HTTP_METHOD, request_info[:method])
+        sentry_span.set_data(Span::DataConventions::HTTP_QUERY, request_info[:query]) if request_info[:query]
+        sentry_span.set_data(Span::DataConventions::HTTP_STATUS_CODE, response_status)
+      end
+
+      def set_propagation_headers(req)
+        Sentry.get_trace_propagation_headers&.each { |k, v| req[k] = v }
+      end
+
+      def record_sentry_breadcrumb(request_info, response_status)
+        crumb = Sentry::Breadcrumb.new(
+          level: get_level(response_status),
+          category: self.class::BREADCRUMB_CATEGORY,
+          type: "info",
+          data: { status: response_status, **request_info }
+        )
+
+        Sentry.add_breadcrumb(crumb)
+      end
+
+      def record_sentry_breadcrumb?
+        Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
+      end
+
+      def propagate_trace?(url)
+        url &&
+          Sentry.initialized? &&
+          Sentry.configuration.propagate_traces &&
+          Sentry.configuration.trace_propagation_targets.any? { |target| url.match?(target) }
+      end
+
+      # Kindly borrowed from Rack::Utils
+      def build_nested_query(value, prefix = nil)
+        case value
+        when Array
+          value.map { |v|
+            build_nested_query(v, "#{prefix}[]")
+          }.join("&")
+        when Hash
+          value.map { |k, v|
+            build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
+          }.delete_if(&:empty?).join("&")
+        when nil
+          URI.encode_www_form_component(prefix)
+        else
+          raise ArgumentError, "value must be a Hash" if prefix.nil?
+          "#{URI.encode_www_form_component(prefix)}=#{URI.encode_www_form_component(value)}"
+        end
+      end
+
+      private
+
+      def get_level(status)
+        return :info unless status && status.is_a?(Integer)
+
+if status >= 500
+  :error
+elsif status >= 400
+  :warning
+else
+  :info
+end
+      end
+    end
+  end
+end

data/lib/sentry/utils/logging_helper.rb

@@ -1,26 +1,29 @@
 # frozen_string_literal: true
 
 module Sentry
+  # @private
   module LoggingHelper
+    # @!visibility private
+    attr_reader :sdk_logger
+
+    # @!visibility private
     def log_error(message, exception, debug: false)
       message = "#{message}: #{exception.message}"
       message += "\n#{exception.backtrace.join("\n")}" if debug
 
-      @logger.error(LOGGER_PROGNAME) do
+      sdk_logger.error(LOGGER_PROGNAME) do
         message
       end
     end
 
-    def log_info(message)
-      @logger.info(LOGGER_PROGNAME) { message }
-    end
-
+    # @!visibility private
     def log_debug(message)
-      @logger.debug(LOGGER_PROGNAME) { message }
+      sdk_logger.debug(LOGGER_PROGNAME) { message }
     end
 
+    # @!visibility private
     def log_warn(message)
-      @logger.warn(LOGGER_PROGNAME) { message }
+      sdk_logger.warn(LOGGER_PROGNAME) { message }
     end
   end
 end

data/lib/sentry/utils/real_ip.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'ipaddr'
+require "ipaddr"
 
 # Based on ActionDispatch::RemoteIp. All security-related precautions from that
 # middleware have been removed, because the Event IP just needs to be accurate,
@@ -15,7 +15,7 @@ module Sentry
         "fc00::/7",       # private IPv6 range fc00::/7
         "10.0.0.0/8",     # private IPv4 range 10.x.x.x
         "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
-        "192.168.0.0/16", # private IPv4 range 192.168.x.x
+        "192.168.0.0/16" # private IPv4 range 192.168.x.x
       ]
 
       attr_reader :ip

data/lib/sentry/utils/request_id.rb

@@ -3,7 +3,7 @@
 module Sentry
   module Utils
     module RequestId
-      REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+      REQUEST_ID_HEADERS = %w[action_dispatch.request_id HTTP_X_REQUEST_ID].freeze
 
       # Request ID based on ActionDispatch::RequestId
       def self.read_from(env)

data/lib/sentry/utils/uuid.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Sentry
+  module Utils
+    DELIMITER = "-"
+
+    def self.uuid
+      SecureRandom.uuid.delete(DELIMITER)
+    end
+  end
+end

data/lib/sentry/vernier/output.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require "rbconfig"
+
+module Sentry
+  module Vernier
+    class Output
+      include Profiler::Helpers
+
+      attr_reader :profile
+
+      def initialize(profile, project_root:, in_app_pattern:, app_dirs_pattern:)
+        @profile = profile
+        @project_root = project_root
+        @in_app_pattern = in_app_pattern
+        @app_dirs_pattern = app_dirs_pattern
+      end
+
+      def to_h
+        @to_h ||= {
+          frames: frames,
+          stacks: stacks,
+          samples: samples,
+          thread_metadata: thread_metadata
+        }
+      end
+
+      private
+
+      def thread_metadata
+        profile.threads.map { |thread_id, thread_info|
+          [thread_id, { name: thread_info[:name] }]
+        }.to_h
+      end
+
+      def samples
+        profile.threads.flat_map { |thread_id, thread_info|
+          started_at = thread_info[:started_at]
+          samples, timestamps = thread_info.values_at(:samples, :timestamps)
+
+          samples.zip(timestamps).map { |stack_id, timestamp|
+            elapsed_since_start_ns = timestamp - started_at
+
+            next if elapsed_since_start_ns < 0
+
+            {
+              thread_id: thread_id.to_s,
+              stack_id: stack_id,
+              elapsed_since_start_ns: elapsed_since_start_ns.to_s
+            }
+          }.compact
+        }
+      end
+
+      def frames
+        funcs = stack_table_hash[:frame_table].fetch(:func)
+        lines = stack_table_hash[:func_table].fetch(:first_line)
+
+        funcs.map do |idx|
+          function, mod = split_module(stack_table_hash[:func_table][:name][idx])
+
+          abs_path = stack_table_hash[:func_table][:filename][idx]
+          in_app = in_app?(abs_path)
+          filename = compute_filename(abs_path, in_app)
+
+          {
+            function: function,
+            module: mod,
+            filename: filename,
+            abs_path: abs_path,
+            lineno: (lineno = lines[idx]) > 0 ? lineno : nil,
+            in_app: in_app
+          }.compact
+        end
+      end
+
+      def stacks
+        profile._stack_table.stack_count.times.map do |stack_id|
+          profile.stack(stack_id).frames.map(&:idx)
+        end
+      end
+
+      def stack_table_hash
+        @stack_table_hash ||= profile._stack_table.to_h
+      end
+    end
+  end
+end

data/lib/sentry/vernier/profiler.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../profiler/helpers"
+require_relative "output"
+require "sentry/utils/uuid"
+
+module Sentry
+  module Vernier
+    class Profiler
+      EMPTY_RESULT = {}.freeze
+
+      attr_reader :started, :event_id, :result
+
+      def initialize(configuration)
+        @event_id = Utils.uuid
+
+        @started = false
+        @sampled = nil
+
+        @profiling_enabled = defined?(Vernier) && configuration.profiling_enabled?
+        @profiles_sample_rate = configuration.profiles_sample_rate
+        @project_root = configuration.project_root
+        @app_dirs_pattern = configuration.app_dirs_pattern
+        @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
+      end
+
+      def set_initial_sample_decision(transaction_sampled)
+        unless @profiling_enabled
+          @sampled = false
+          return
+        end
+
+        unless transaction_sampled
+          @sampled = false
+          log("Discarding profile because transaction not sampled")
+          return
+        end
+
+        case @profiles_sample_rate
+        when 0.0
+          @sampled = false
+          log("Discarding profile because sample_rate is 0")
+          return
+        when 1.0
+          @sampled = true
+          return
+        else
+          @sampled = Random.rand < @profiles_sample_rate
+        end
+
+        log("Discarding profile due to sampling decision") unless @sampled
+      end
+
+      def start
+        return unless @sampled
+        return if @started
+
+        @started = ::Vernier.start_profile
+
+        log("Started")
+
+        @started
+      rescue RuntimeError => e
+        # TODO: once Vernier raises something more dedicated, we should catch that instead
+        if e.message.include?("Profile already started")
+          log("Not started since running elsewhere")
+        else
+          log("Failed to start: #{e.message}")
+        end
+      end
+
+      def stop
+        return unless @sampled
+        return unless @started
+
+        @result = ::Vernier.stop_profile
+        @started = false
+
+        log("Stopped")
+      rescue RuntimeError => e
+        if e.message.include?("Profile not started")
+          log("Not stopped since not started")
+        else
+          log("Failed to stop Vernier: #{e.message}")
+        end
+      end
+
+      def active_thread_id
+        Thread.current.object_id
+      end
+
+      def to_hash
+        unless @sampled
+          record_lost_event(:sample_rate)
+          return EMPTY_RESULT
+        end
+
+        return EMPTY_RESULT unless result
+
+        { **profile_meta, profile: output.to_h }
+      end
+
+      private
+
+      def log(message)
+        Sentry.sdk_logger.debug(LOGGER_PROGNAME) { "[Profiler::Vernier] #{message}" }
+      end
+
+      def record_lost_event(reason)
+        Sentry.get_current_client&.transport&.record_lost_event(reason, "profile")
+      end
+
+      def profile_meta
+        {
+          event_id: @event_id,
+          version: "1",
+          platform: "ruby"
+        }
+      end
+
+      def output
+        @output ||= Output.new(
+          result,
+          project_root: @project_root,
+          app_dirs_pattern: @app_dirs_pattern,
+          in_app_pattern: @in_app_pattern
+        )
+      end
+    end
+  end
+end

data/lib/sentry/version.rb

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