sentry-ruby 5.10.0 → 5.26.0

data/lib/sentry/envelope/item.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Envelope::Item
+    STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
+    MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
+
+    SIZE_LIMITS = Hash.new(MAX_SERIALIZED_PAYLOAD_SIZE).update(
+      "profile" => 1024 * 1000 * 50
+    )
+
+    attr_reader :size_limit, :headers, :payload, :type, :data_category
+
+    # 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 "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"
+      end
+    end
+
+    def initialize(headers, payload)
+      @headers = headers
+      @payload = payload
+      @type = headers[:type] || "event"
+      @data_category = self.class.data_category(type)
+      @size_limit = SIZE_LIMITS[type]
+    end
+
+    def to_s
+      [JSON.generate(@headers), @payload.is_a?(String) ? @payload : JSON.generate(@payload)].join("\n")
+    end
+
+    def serialize
+      result = to_s
+
+      if result.bytesize > size_limit
+        remove_breadcrumbs!
+        result = to_s
+      end
+
+      if result.bytesize > size_limit
+        reduce_stacktrace!
+        result = to_s
+      end
+
+      [result, result.bytesize > size_limit]
+    end
+
+    def size_breakdown
+      payload.map do |key, value|
+        "#{key}: #{JSON.generate(value).bytesize}"
+      end.join(", ")
+    end
+
+    private
+
+    def remove_breadcrumbs!
+      if payload.key?(:breadcrumbs)
+        payload.delete(:breadcrumbs)
+      elsif payload.key?("breadcrumbs")
+        payload.delete("breadcrumbs")
+      end
+    end
+
+    def reduce_stacktrace!
+      if exceptions = payload.dig(:exception, :values) || payload.dig("exception", "values")
+        exceptions.each do |exception|
+          # in most cases there is only one exception (2 or 3 when have multiple causes), so we won't loop through this double condition much
+          traces = exception.dig(:stacktrace, :frames) || exception.dig("stacktrace", "frames")
+
+          if traces && traces.size > STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD
+            size_on_both_ends = STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD / 2
+            traces.replace(
+              traces[0..(size_on_both_ends - 1)] + traces[-size_on_both_ends..-1],
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/envelope.rb

@@ -3,74 +3,6 @@
 module Sentry
   # @api private
   class Envelope
-    class Item
-      STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
-      MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 200
-
-      attr_accessor :headers, :payload
-
-      def initialize(headers, payload)
-        @headers = headers
-        @payload = payload
-      end
-
-      def type
-        @headers[:type] || 'event'
-      end
-
-      def to_s
-        [JSON.generate(@headers), JSON.generate(@payload)].join("\n")
-      end
-
-      def serialize
-        result = to_s
-
-        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
-          remove_breadcrumbs!
-          result = to_s
-        end
-
-        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
-          reduce_stacktrace!
-          result = to_s
-        end
-
-        [result, result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE]
-      end
-
-      def size_breakdown
-        payload.map do |key, value|
-          "#{key}: #{JSON.generate(value).bytesize}"
-        end.join(", ")
-      end
-
-      private
-
-      def remove_breadcrumbs!
-        if payload.key?(:breadcrumbs)
-          payload.delete(:breadcrumbs)
-        elsif payload.key?("breadcrumbs")
-          payload.delete("breadcrumbs")
-        end
-      end
-
-      def reduce_stacktrace!
-        if exceptions = payload.dig(:exception, :values) || payload.dig("exception", "values")
-          exceptions.each do |exception|
-            # in most cases there is only one exception (2 or 3 when have multiple causes), so we won't loop through this double condition much
-            traces = exception.dig(:stacktrace, :frames) || exception.dig("stacktrace", "frames")
-
-            if traces && traces.size > STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD
-              size_on_both_ends = STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD / 2
-              traces.replace(
-                traces[0..(size_on_both_ends - 1)] + traces[-size_on_both_ends..-1],
-              )
-            end
-          end
-        end
-      end
-    end
-
     attr_accessor :headers, :items
 
     def initialize(headers = {})
@@ -91,3 +23,5 @@ module Sentry
     end
   end
 end
+
+require_relative "envelope/item"

data/lib/sentry/error_event.rb

@@ -27,12 +27,12 @@ module Sentry
     end
 
     # @!visibility private
-    def add_exception_interface(exception)
+    def add_exception_interface(exception, mechanism:)
       if exception.respond_to?(:sentry_context)
         @extra.merge!(exception.sentry_context)
       end
 
-      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder, mechanism: mechanism)
     end
   end
 end

data/lib/sentry/event.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require 'socket'
-require 'securerandom'
-require 'sentry/interface'
-require 'sentry/backtrace'
-require 'sentry/utils/real_ip'
-require 'sentry/utils/request_id'
-require 'sentry/utils/custom_inspection'
+require "socket"
+require "securerandom"
+require "sentry/interface"
+require "sentry/backtrace"
+require "sentry/utils/real_ip"
+require "sentry/utils/request_id"
+require "sentry/utils/custom_inspection"
+require "sentry/utils/uuid"
 
 module Sentry
   # This is an abstract class that defines the shared attributes of an event.
@@ -14,16 +15,16 @@ module Sentry
   class Event
     TYPE = "event"
     # These are readable attributes.
-    SERIALIZEABLE_ATTRIBUTES = %i(
+    SERIALIZEABLE_ATTRIBUTES = %i[
       event_id level timestamp
       release environment server_name modules
       message user tags contexts extra
       fingerprint breadcrumbs transaction transaction_info
       platform sdk type
-    )
+    ]
 
     # These are writable attributes.
-    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp level)
+    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i[type timestamp level]
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
@@ -37,12 +38,20 @@ module Sentry
     # @return [RequestInterface]
     attr_reader :request
 
+    # Dynamic Sampling Context (DSC) that gets attached
+    # as the trace envelope header in the transport.
+    # @return [Hash, nil]
+    attr_accessor :dynamic_sampling_context
+
+    # @return [Array<Attachment>]
+    attr_accessor :attachments
+
     # @param configuration [Configuration]
     # @param integration_meta [Hash, nil]
     # @param message [String, nil]
     def initialize(configuration:, integration_meta: nil, message: nil)
       # Set some simple default values
-      @event_id      = SecureRandom.uuid.delete("-")
+      @event_id      = Utils.uuid
       @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
       @type          = self.class::TYPE
@@ -52,8 +61,10 @@ module Sentry
       @extra         = {}
       @contexts      = {}
       @tags          = {}
+      @attachments   = []
 
       @fingerprint = []
+      @dynamic_sampling_context = nil
 
       # configuration data that's directly used by events
       @server_name = configuration.server_name
@@ -70,34 +81,6 @@ module Sentry
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
     end
 
-    class << self
-      # @!visibility private
-      def get_log_message(event_hash)
-        message = event_hash[:message] || event_hash['message']
-
-        return message unless message.nil? || message.empty?
-
-        message = get_message_from_exception(event_hash)
-
-        return message unless message.nil? || message.empty?
-
-        message = event_hash[:transaction] || event_hash["transaction"]
-
-        return message unless message.nil? || message.empty?
-
-        '<no message value>'
-      end
-
-      # @!visibility private
-      def get_message_from_exception(event_hash)
-        if exception = event_hash.dig(:exception, :values, 0)
-          "#{exception[:type]}: #{exception[:value]}"
-        elsif exception = event_hash.dig("exception", "values", 0)
-          "#{exception["type"]}: #{exception["value"]}"
-        end
-      end
-    end
-
     # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
     # @return [Configuration]
     def configuration
@@ -126,9 +109,7 @@ module Sentry
       unless request || env.empty?
         add_request_interface(env)
 
-        if @send_default_pii
-          user[:ip_address] = calculate_real_ip_from_rack(env)
-        end
+        user[:ip_address] ||= calculate_real_ip_from_rack(env) if @send_default_pii
 
         if request_id = Utils::RequestId.read_from(env)
           tags[:request_id] = request_id
@@ -167,11 +148,11 @@ module Sentry
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack(env)
       Utils::RealIp.new(
-        :remote_addr => env["REMOTE_ADDR"],
-        :client_ip => env["HTTP_CLIENT_IP"],
-        :real_ip => env["HTTP_X_REAL_IP"],
-        :forwarded_for => env["HTTP_X_FORWARDED_FOR"],
-        :trusted_proxies => @trusted_proxies
+        remote_addr: env["REMOTE_ADDR"],
+        client_ip: env["HTTP_CLIENT_IP"],
+        real_ip: env["HTTP_X_REAL_IP"],
+        forwarded_for: env["HTTP_X_FORWARDED_FOR"],
+        trusted_proxies: @trusted_proxies
       ).calculate_ip
     end
   end

data/lib/sentry/excon/middleware.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Excon
+    OP_NAME = "http.client"
+
+    class Middleware < ::Excon::Middleware::Base
+      def initialize(stack)
+        super
+        @instrumenter = Instrumenter.new
+      end
+
+      def request_call(datum)
+        @instrumenter.start_transaction(datum)
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        @instrumenter.finish_transaction(datum)
+        @stack.response_call(datum)
+      end
+    end
+
+    class Instrumenter
+      SPAN_ORIGIN = "auto.http.excon"
+      BREADCRUMB_CATEGORY = "http"
+
+      include Utils::HttpTracing
+
+      def start_transaction(env)
+        return unless Sentry.initialized?
+
+        current_span = Sentry.get_current_scope&.span
+        @span = current_span&.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN)
+
+        request_info = extract_request_info(env)
+
+        if propagate_trace?(request_info[:url])
+          set_propagation_headers(env[:headers])
+        end
+      end
+
+      def finish_transaction(response)
+        return unless @span
+
+        response_status = response[:response][:status]
+        request_info = extract_request_info(response)
+
+        if record_sentry_breadcrumb?
+          record_sentry_breadcrumb(request_info, response_status)
+        end
+
+        set_span_info(@span, request_info, response_status)
+      ensure
+        @span&.finish
+      end
+
+      private
+
+      def extract_request_info(env)
+        url = env[:scheme] + "://" + env[:hostname] + env[:path]
+        result = { method: env[:method].to_s.upcase, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:query] = env[:query]
+
+          # Handle excon 1.0.0+
+          result[:query] = build_nested_query(result[:query]) unless result[:query].is_a?(String)
+
+          result[:body] = env[:body]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/sentry/excon.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Sentry.register_patch(:excon) do
+  if defined?(::Excon)
+    require "sentry/excon/middleware"
+    if Excon.defaults[:middlewares]
+      Excon.defaults[:middlewares] << Sentry::Excon::Middleware unless Excon.defaults[:middlewares].include?(Sentry::Excon::Middleware)
+    end
+  end
+end

data/lib/sentry/faraday.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Faraday
+    OP_NAME = "http.client"
+
+    module Connection
+      # Since there's no way to preconfigure Faraday connections and add our instrumentation
+      # by default, we need to extend the connection constructor and do it there
+      #
+      # @see https://lostisland.github.io/faraday/#/customization/index?id=configuration
+      def initialize(url = nil, options = nil)
+        super
+
+        # Ensure that we attach instrumentation only if the adapter is not net/http
+        # because if is is, then the net/http instrumentation will take care of it
+        if builder.adapter.name != "Faraday::Adapter::NetHttp"
+          # Make sure that it's going to be the first middleware so that it can capture
+          # the entire request processing involving other middlewares
+          builder.insert(0, ::Faraday::Request::Instrumentation, name: OP_NAME, instrumenter: Instrumenter.new)
+        end
+      end
+    end
+
+    class Instrumenter
+      SPAN_ORIGIN = "auto.http.faraday"
+      BREADCRUMB_CATEGORY = "http"
+
+      include Utils::HttpTracing
+
+      def instrument(op_name, env, &block)
+        return block.call unless Sentry.initialized?
+
+        Sentry.with_child_span(op: op_name, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |sentry_span|
+          request_info = extract_request_info(env)
+
+          if propagate_trace?(request_info[:url])
+            set_propagation_headers(env[:request_headers])
+          end
+
+          res = block.call
+          response_status = res.status
+
+          if record_sentry_breadcrumb?
+            record_sentry_breadcrumb(request_info, response_status)
+          end
+
+          if sentry_span
+            set_span_info(sentry_span, request_info, response_status)
+          end
+
+          res
+        end
+      end
+
+      private
+
+      def extract_request_info(env)
+        url = env[:url].scheme + "://" + env[:url].host + env[:url].path
+        result = { method: env[:method].to_s.upcase, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:query] = env[:url].query
+          result[:body] = env[:body]
+        end
+
+        result
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:faraday) do
+  if defined?(::Faraday)
+    ::Faraday::Connection.prepend(Sentry::Faraday::Connection)
+  end
+end

data/lib/sentry/graphql.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+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." }
+  end
+end