sentry-ruby-core 4.2.2 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 927808cee7826c8aa7535511858722699330cd16b430ad68b7a7b79aaf04546d
-  data.tar.gz: 779f0e49611a24e1149fa551ff8988e15ac684bb2e9eb0c70a6c96b33501086d
+  metadata.gz: 66ef212c06425a29b56b64935c1fb662633fa80fb9f58b9680b1d95220ee8b5d
+  data.tar.gz: 18e211d0c93d18717795b23290c2cb7da503b0dcd1690c1c8b51861c3a37ef98
 SHA512:
-  metadata.gz: d629d892096a9de47f89f62c62487eb536c059c0ce14f6263aa605b50c2eddd0d5ecb48ed5da094444e58a889b8800b3333456cfa3c5e3e6afd4b6ea0512f081
-  data.tar.gz: 19a781d62efd5af40367146c976e2a1d886c59fbeddc6d67ad3e4efee15744ef34efd0769abb39317ee6b94d768394f7a6cf468a539d44894e595bd384ffc4cb
+  metadata.gz: e334875a26a04e45a78c37e7bb0014604cd2b400b89eb01faa3ae21adc1f9072e46227ce880c1406148e32d6a125504dc08ffab5e1ac61c0b3befbd31e5352ea
+  data.tar.gz: 4c01fb8d489a3d143a738180f3f68ba62d3882267ecf17b82c3cf0e509ab36a8b458699d022d5d55699baacaccd2acc3bfede0d332ae5b50776128ac5c164a2a

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 4.3.0
+
+### Features
+
+- Allow configuring BreadcrumbBuffer's size limit [#1310](https://github.com/getsentry/sentry-ruby/pull/1310)
+
+```ruby
+# the SDK will only store 10 breadcrumbs (default is 100)
+config.max_breadcrumbs = 10
+```
+
+- Compress event payload by default [#1314](https://github.com/getsentry/sentry-ruby/pull/1314)
+
+### Refatorings
+
+- Refactor interface construction [#1296](https://github.com/getsentry/sentry-ruby/pull/1296)
+- Refactor tracing implementation [#1309](https://github.com/getsentry/sentry-ruby/pull/1309)
+
+### Bug Fixes
+- Improve SDK's error handling [#1298](https://github.com/getsentry/sentry-ruby/pull/1298)
+  - Fixes [#1246](https://github.com/getsentry/sentry-ruby/issues/1246) and [#1289](https://github.com/getsentry/sentry-ruby/issues/1289)
+  - Please read [#1290](https://github.com/getsentry/sentry-ruby/issues/1290) to see the full specification
+- Treat query string as pii too [#1302](https://github.com/getsentry/sentry-ruby/pull/1302)
+  - Fixes [#1301](https://github.com/getsentry/sentry-ruby/issues/1301)
+- Ignore sentry-trace when tracing is not enabled [#1308](https://github.com/getsentry/sentry-ruby/pull/1308)
+  - Fixes [#1307](https://github.com/getsentry/sentry-ruby/issues/1307)
+- Return nil from logger methods instead of breadcrumb buffer [#1299](https://github.com/getsentry/sentry-ruby/pull/1299)
+- Exceptions with nil message shouldn't cause issues [#1327](https://github.com/getsentry/sentry-ruby/pull/1327)
+  - Fixes [#1323](https://github.com/getsentry/sentry-ruby/issues/1323)
+- Fix sampling decision with sentry-trace and add more tests [#1326](https://github.com/getsentry/sentry-ruby/pull/1326)
+
 ## 4.2.2
 
 - Add thread_id to Exception interface [#1291](https://github.com/getsentry/sentry-ruby/pull/1291)

data/README.md

@@ -2,10 +2,14 @@
   <a href="https://sentry.io" target="_blank" align="center">
     <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" width="280">
   </a>
-  <br>
+  <br />
 </p>
 
-# sentry-ruby, the Ruby Client for Sentry
+_Bad software is everywhere, and we're tired of it. Sentry is on a mission to help developers write better software faster, so we can get back to enjoying technology. If you want to join us [<kbd>**Check out our open positions**</kbd>](https://sentry.io/careers/)_
+
+Sentry SDK for Ruby
+===========
+
 
 **The old `sentry-raven` client has entered maintenance mode and was moved to [here](https://github.com/getsentry/sentry-ruby/tree/master/sentry-raven).**
 

data/lib/sentry-ruby.rb

@@ -3,6 +3,7 @@ require "forwardable"
 require "time"
 
 require "sentry/version"
+require "sentry/exceptions"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/utils/argument_checking_helper"
 require "sentry/configuration"
@@ -26,9 +27,6 @@ require "sentry/background_worker"
 end
 
 module Sentry
-  class Error < StandardError
-  end
-
   META = { "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
 
   LOGGER_PROGNAME = "sentry".freeze
@@ -68,7 +66,7 @@ module Sentry
       config = Configuration.new
       yield(config) if block_given?
       client = Client.new(config)
-      scope = Scope.new
+      scope = Scope.new(max_breadcrumbs: config.max_breadcrumbs)
       hub = Hub.new(client, scope)
       Thread.current[THREAD_LOCAL] = hub
       @main_hub = hub

data/lib/sentry/background_worker.rb

@@ -1,5 +1,6 @@
 require "concurrent/executor/thread_pool_executor"
 require "concurrent/executor/immediate_executor"
+require "concurrent/configuration"
 
 module Sentry
   class BackgroundWorker

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -14,6 +14,7 @@ module Sentry
       def add(*args, &block)
         super
         add_breadcrumb(*args, &block)
+        nil
       end
 
       def add_breadcrumb(severity, message = nil, progname = nil)

data/lib/sentry/breadcrumb_buffer.rb

@@ -2,12 +2,13 @@ require "sentry/breadcrumb"
 
 module Sentry
   class BreadcrumbBuffer
+    DEFAULT_SIZE = 100
     include Enumerable
 
     attr_accessor :buffer
 
-    def initialize(size = 100)
-      @buffer = Array.new(size)
+    def initialize(size = nil)
+      @buffer = Array.new(size || DEFAULT_SIZE)
     end
 
     def record(crumb)

data/lib/sentry/client.rb

@@ -2,10 +2,11 @@ require "sentry/transport"
 
 module Sentry
   class Client
-    attr_reader :transport, :configuration
+    attr_reader :transport, :configuration, :logger
 
     def initialize(configuration)
       @configuration = configuration
+      @logger = configuration.logger
 
       if transport_class = configuration.transport.transport_class
         @transport = transport_class.new(configuration)
@@ -26,32 +27,17 @@ module Sentry
       scope.apply_to_event(event, hint)
 
       if async_block = configuration.async
-        begin
-          # We have to convert to a JSON-like hash, because background job
-          # processors (esp ActiveJob) may not like weird types in the event hash
-          event_hash = event.to_json_compatible
-
-          if async_block.arity == 2
-            hint = JSON.parse(JSON.generate(hint))
-            async_block.call(event_hash, hint)
-          else
-            async_block.call(event_hash)
-          end
-        rescue => e
-          configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
-          send_event(event, hint)
-        end
+        dispatch_async_event(async_block, event, hint)
+      elsif hint.fetch(:background, true)
+        dispatch_background_event(event, hint)
       else
-        if hint.fetch(:background, true)
-          Sentry.background_worker.perform do
-            send_event(event, hint)
-          end
-        else
-          send_event(event, hint)
-        end
+        send_event(event, hint)
       end
 
       event
+    rescue => e
+      logger.error(LOGGER_PROGNAME) { "Event capturing failed: #{e.message}" }
+      nil
     end
 
     def event_from_exception(exception, hint = {})
@@ -85,16 +71,49 @@ module Sentry
 
     def send_event(event, hint = nil)
       event_type = event.is_a?(Event) ? event.type : event["type"]
-      event = configuration.before_send.call(event, hint) if configuration.before_send && event_type == "event"
 
-      if event.nil?
-        configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
-        return
+      if event_type == "event" && configuration.before_send
+        event = configuration.before_send.call(event, hint)
+
+        if event.nil?
+          logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
+          return
+        end
       end
 
       transport.send_event(event)
 
       event
+    rescue => e
+      logger.error(LOGGER_PROGNAME) { "#{event_type.capitalize} sending failed: #{e.message}" }
+      logger.error(LOGGER_PROGNAME) { "Unreported #{event_type.capitalize}: #{Event.get_log_message(event.to_hash)}" }
+      raise
     end
+
+    private
+
+    def dispatch_background_event(event, hint)
+      Sentry.background_worker.perform do
+        send_event(event, hint)
+      end
+    end
+
+    def dispatch_async_event(async_block, event, hint)
+      # We have to convert to a JSON-like hash, because background job
+      # processors (esp ActiveJob) may not like weird types in the event hash
+      event_hash = event.to_json_compatible
+
+      if async_block.arity == 2
+        hint = JSON.parse(JSON.generate(hint))
+        async_block.call(event_hash, hint)
+      else
+        async_block.call(event_hash)
+      end
+    rescue => e
+      event_type = event_hash["type"]
+      logger.error(LOGGER_PROGNAME) { "Async #{event_type} sending failed: #{e.message}" }
+      send_event(event, hint)
+    end
+
   end
 end

data/lib/sentry/configuration.rb

@@ -4,6 +4,7 @@ require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
 require "sentry/linecache"
+require "sentry/interfaces/stacktrace_builder"
 
 module Sentry
   class Configuration
@@ -61,6 +62,9 @@ module Sentry
     # - :active_support_logger
     attr_reader :breadcrumbs_logger
 
+    # Max number of breadcrumbs a breadcrumb buffer can hold
+    attr_accessor :max_breadcrumbs
+
     # Number of lines of code context to capture, or nil for none
     attr_accessor :context_lines
 
@@ -171,6 +175,7 @@ module Sentry
 
     def initialize
       self.background_worker_threads = Concurrent.processor_count
+      self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
       self.environment = environment_from_env
@@ -195,6 +200,7 @@ module Sentry
 
       @transport = Transport::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
+
       run_post_initialization_callbacks
     end
 
@@ -290,6 +296,16 @@ module Sentry
       !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
     end
 
+    def stacktrace_builder
+      @stacktrace_builder ||= StacktraceBuilder.new(
+        project_root: @project_root.to_s,
+        app_dirs_pattern: @app_dirs_pattern,
+        linecache: @linecache,
+        context_lines: @context_lines,
+        backtrace_cleanup_callback: @backtrace_cleanup_callback
+      )
+    end
+
     private
 
     def detect_release

data/lib/sentry/event.rb

@@ -20,7 +20,7 @@ module Sentry
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration, :request, :exception, :stacktrace, :threads
+    attr_reader :configuration, :request, :exception, :threads
 
     def initialize(configuration:, integration_meta: nil, message: nil)
       # this needs to go first because some setters rely on configuration
@@ -52,19 +52,26 @@ module Sentry
     class << self
       def get_log_message(event_hash)
         message = event_hash[:message] || event_hash['message']
-        message = get_message_from_exception(event_hash) if message.nil? || message.empty?
-        message = '<no message value>' if message.nil? || message.empty?
-        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
 
       def get_message_from_exception(event_hash)
-        (
-          event_hash &&
-          event_hash[:exception] &&
-          event_hash[:exception][:values] &&
-          event_hash[:exception][:values][0] &&
-          "#{event_hash[:exception][:values][0][:type]}: #{event_hash[:exception][:values][0][:value]}"
-        )
+        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
 
@@ -99,7 +106,6 @@ module Sentry
     def to_hash
       data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:stacktrace] = stacktrace.to_hash if stacktrace
       data[:request] = request.to_hash if request
       data[:exception] = exception.to_hash if exception
       data[:threads] = threads.to_hash if threads
@@ -112,48 +118,23 @@ module Sentry
     end
 
     def add_request_interface(env)
-      @request = Sentry::RequestInterface.from_rack(env)
+      @request = Sentry::RequestInterface.build(env: env)
     end
 
     def add_threads_interface(backtrace: nil, **options)
-      @threads = ThreadsInterface.new(**options)
-      @threads.stacktrace = initialize_stacktrace_interface(backtrace) if backtrace
+      @threads = ThreadsInterface.build(
+        backtrace: backtrace,
+        stacktrace_builder: configuration.stacktrace_builder,
+        **options
+      )
     end
 
-    def add_exception_interface(exc)
-      if exc.respond_to?(:sentry_context)
-        @extra.merge!(exc.sentry_context)
+    def add_exception_interface(exception)
+      if exception.respond_to?(:sentry_context)
+        @extra.merge!(exception.sentry_context)
       end
 
-      @exception = Sentry::ExceptionInterface.new.tap do |exc_int|
-        exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
-        backtraces = Set.new
-        exc_int.values = exceptions.map do |e|
-          SingleExceptionInterface.new.tap do |int|
-            int.type = e.class.to_s
-            int.value = e.message.byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
-            int.module = e.class.to_s.split('::')[0...-1].join('::')
-            int.thread_id = Thread.current.object_id
-
-            int.stacktrace =
-              if e.backtrace && !backtraces.include?(e.backtrace.object_id)
-                backtraces << e.backtrace.object_id
-                initialize_stacktrace_interface(e.backtrace)
-              end
-          end
-        end
-      end
-    end
-
-    def initialize_stacktrace_interface(backtrace)
-      StacktraceInterface.new(
-        backtrace: backtrace,
-        project_root: configuration.project_root.to_s,
-        app_dirs_pattern: configuration.app_dirs_pattern,
-        linecache: configuration.linecache,
-        context_lines: configuration.context_lines,
-        backtrace_cleanup_callback: configuration.backtrace_cleanup_callback
-      )
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: configuration.stacktrace_builder)
     end
 
     private

data/lib/sentry/exceptions.rb

@@ -0,0 +1,7 @@
+module Sentry
+  class Error < StandardError
+  end
+
+  class ExternalError < StandardError
+  end
+end

data/lib/sentry/hub.rb

@@ -69,9 +69,11 @@ module Sentry
       @stack.pop
     end
 
-    def start_transaction(transaction: nil, **options)
+    def start_transaction(transaction: nil, configuration: Sentry.configuration, **options)
+      return unless configuration.tracing_enabled?
+
       transaction ||= Transaction.new(**options)
-      transaction.set_initial_sample_desicion
+      transaction.set_initial_sample_decision(configuration: current_client.configuration)
       transaction
     end
 

data/lib/sentry/interfaces/exception.rb

@@ -1,11 +1,29 @@
 module Sentry
   class ExceptionInterface < Interface
-    attr_accessor :values
+    def initialize(values:)
+      @values = values
+    end
 
     def to_hash
       data = super
       data[:values] = data[:values].map(&:to_hash) if data[:values]
       data
     end
+
+    def self.build(exception:, stacktrace_builder:)
+      exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exception).reverse
+      processed_backtrace_ids = Set.new
+
+      exceptions = exceptions.map do |e|
+        if e.backtrace && !processed_backtrace_ids.include?(e.backtrace.object_id)
+          processed_backtrace_ids << e.backtrace.object_id
+          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder)
+        else
+          SingleExceptionInterface.new(exception: exception)
+        end
+      end
+
+      new(values: exceptions)
+    end
   end
 end

data/lib/sentry/interfaces/request.rb

@@ -17,10 +17,10 @@ module Sentry
 
     attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
 
-    def self.from_rack(env)
+    def self.build(env:)
       env = clean_env(env)
-      req = ::Rack::Request.new(env)
-      self.new(req)
+      request = ::Rack::Request.new(env)
+      self.new(request: request)
     end
 
     def self.clean_env(env)
@@ -34,17 +34,17 @@ module Sentry
       env
     end
 
-    def initialize(req)
-      env = req.env
+    def initialize(request:)
+      env = request.env
 
       if Sentry.configuration.send_default_pii
-        self.data = read_data_from(req)
-        self.cookies = req.cookies
+        self.data = read_data_from(request)
+        self.cookies = request.cookies
+        self.query_string = request.query_string
       end
 
-      self.url = req.scheme && req.url.split('?').first
-      self.method = req.request_method
-      self.query_string = req.query_string
+      self.url = request.scheme && request.url.split('?').first
+      self.method = request.request_method
 
       self.headers = filter_and_format_headers(env)
       self.env     = filter_and_format_env(env)

data/lib/sentry/interfaces/single_exception.rb

@@ -1,15 +1,26 @@
 module Sentry
   class SingleExceptionInterface < Interface
-    attr_accessor :type
-    attr_accessor :value
-    attr_accessor :module
-    attr_accessor :thread_id
-    attr_accessor :stacktrace
+    attr_reader :type, :value, :module, :thread_id, :stacktrace
+
+    def initialize(exception:, stacktrace: nil)
+      @type = exception.class.to_s
+      @value = (exception.message || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+      @module = exception.class.to_s.split('::')[0...-1].join('::')
+      @thread_id = Thread.current.object_id
+      @stacktrace = stacktrace
+    end
 
     def to_hash
       data = super
       data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
       data
     end
+
+    # patch this method if you want to change an exception's stacktrace frames
+    # also see `StacktraceBuilder.build`.
+    def self.build_with_stacktrace(exception:, stacktrace_builder:)
+      stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
+      new(exception: exception, stacktrace: stacktrace)
+    end
   end
 end

data/lib/sentry/interfaces/stacktrace.rb

@@ -2,18 +2,8 @@ module Sentry
   class StacktraceInterface
     attr_reader :frames
 
-    def initialize(backtrace:, project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
-      @project_root = project_root
-      @frames = []
-
-      parsed_backtrace_lines = Backtrace.parse(
-        backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback
-      ).lines
-
-      parsed_backtrace_lines.reverse.each_with_object(@frames) do |line, frames|
-        frame = convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
-        frames << frame if frame.filename
-      end
+    def initialize(frames:)
+      @frames = frames
     end
 
     def to_hash
@@ -22,30 +12,24 @@ module Sentry
 
     private
 
-    def convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
-      frame = StacktraceInterface::Frame.new(@project_root, line)
-      frame.set_context(linecache, context_lines) if context_lines
-      frame
-    end
-
     # Not actually an interface, but I want to use the same style
     class Frame < Interface
-      attr_accessor :abs_path, :context_line, :function, :in_app,
-                    :lineno, :module, :pre_context, :post_context, :vars
+      attr_accessor :abs_path, :context_line, :function, :in_app, :filename,
+                  :lineno, :module, :pre_context, :post_context, :vars
 
       def initialize(project_root, line)
         @project_root = project_root
 
-        @abs_path = line.file if line.file
+        @abs_path = line.file
         @function = line.method if line.method
         @lineno = line.number
         @in_app = line.in_app
         @module = line.module_name if line.module_name
+        @filename = compute_filename
       end
 
-      def filename
+      def compute_filename
         return if abs_path.nil?
-        return @filename if instance_variable_defined?(:@filename)
 
         prefix =
           if under_project_root? && in_app
@@ -56,19 +40,18 @@ module Sentry
             longest_load_path
           end
 
-        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+        prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
       end
 
       def set_context(linecache, context_lines)
         return unless abs_path
 
-        self.pre_context, self.context_line, self.post_context = \
+        @pre_context, @context_line, @post_context = \
             linecache.get_file_context(abs_path, lineno, context_lines)
       end
 
       def to_hash(*args)
         data = super(*args)
-        data[:filename] = filename
         data.delete(:vars) unless vars && !vars.empty?
         data.delete(:pre_context) unless pre_context && !pre_context.empty?
         data.delete(:post_context) unless post_context && !post_context.empty?

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -0,0 +1,50 @@
+module Sentry
+  class StacktraceBuilder
+    attr_reader :project_root, :app_dirs_pattern, :linecache, :context_lines, :backtrace_cleanup_callback
+
+    def initialize(project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
+      @project_root = project_root
+      @app_dirs_pattern = app_dirs_pattern
+      @linecache = linecache
+      @context_lines = context_lines
+      @backtrace_cleanup_callback = backtrace_cleanup_callback
+    end
+
+    # you can pass a block to customize/exclude frames:
+    #
+    # ```ruby
+    # builder.build(backtrace) do |frame|
+    #   if frame.module.match?(/a_gem/)
+    #     nil
+    #   else
+    #     frame
+    #   end
+    # end
+    # ```
+    def build(backtrace:, &frame_callback)
+      parsed_lines = parse_backtrace_lines(backtrace).select(&:file)
+
+      frames = parsed_lines.reverse.map do |line|
+        frame = convert_parsed_line_into_frame(line)
+        frame = frame_callback.call(frame) if frame_callback
+        frame
+      end.compact
+
+      StacktraceInterface.new(frames: frames)
+    end
+
+    private
+
+    def convert_parsed_line_into_frame(line)
+      frame = StacktraceInterface::Frame.new(project_root, line)
+      frame.set_context(linecache, context_lines) if context_lines
+      frame
+    end
+
+    def parse_backtrace_lines(backtrace)
+      Backtrace.parse(
+        backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback
+      ).lines
+    end
+  end
+end

data/lib/sentry/interfaces/threads.rb

@@ -1,12 +1,11 @@
 module Sentry
   class ThreadsInterface
-    attr_accessor :stacktrace
-
-    def initialize(crashed: false)
+    def initialize(crashed: false, stacktrace: nil)
       @id = Thread.current.object_id
       @name = Thread.current.name
       @current = true
       @crashed = crashed
+      @stacktrace = stacktrace
     end
 
     def to_hash
@@ -22,5 +21,12 @@ module Sentry
         ]
       }
     end
+
+    # patch this method if you want to change a threads interface's stacktrace frames
+    # also see `StacktraceBuilder.build`.
+    def self.build(backtrace:, stacktrace_builder:, **options)
+      stacktrace = stacktrace_builder.build(backtrace: backtrace) if backtrace
+      new(**options, stacktrace: stacktrace)
+    end
   end
 end

data/lib/sentry/rack/capture_exceptions.rb

@@ -16,27 +16,24 @@ module Sentry
           scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
           scope.set_rack_env(env)
 
-          sentry_trace = env["HTTP_SENTRY_TRACE"]
-          span = Sentry::Transaction.from_sentry_trace(sentry_trace, name: scope.transaction_name, op: transaction_op) if sentry_trace
-          span ||= Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
-
-          scope.set_span(span)
+          transaction = start_transaction(env, scope)
+          scope.set_span(transaction) if transaction
 
           begin
             response = @app.call(env)
           rescue Sentry::Error
-            finish_span(span, 500)
+            finish_transaction(transaction, 500)
             raise # Don't capture Sentry errors
           rescue Exception => e
             capture_exception(e)
-            finish_span(span, 500)
+            finish_transaction(transaction, 500)
             raise
           end
 
           exception = collect_exception(env)
           capture_exception(exception) if exception
 
-          finish_span(span, response[0])
+          finish_transaction(transaction, response[0])
 
           response
         end
@@ -56,9 +53,19 @@ module Sentry
         Sentry.capture_exception(exception)
       end
 
-      def finish_span(span, status_code)
-        span.set_http_status(status_code)
-        span.finish
+      def start_transaction(env, scope)
+        sentry_trace = env["HTTP_SENTRY_TRACE"]
+        options = { name: scope.transaction_name, op: transaction_op }
+        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+        Sentry.start_transaction(transaction: transaction, **options)
+      end
+
+
+      def finish_transaction(transaction, status_code)
+        return unless transaction
+
+        transaction.set_http_status(status_code)
+        transaction.finish
       end
     end
   end

data/lib/sentry/scope.rb

@@ -9,7 +9,8 @@ module Sentry
 
     attr_reader(*ATTRIBUTES)
 
-    def initialize
+    def initialize(max_breadcrumbs: nil)
+      @max_breadcrumbs = max_breadcrumbs
       set_default_value
     end
 
@@ -47,7 +48,7 @@ module Sentry
     end
 
     def clear_breadcrumbs
-      @breadcrumbs = BreadcrumbBuffer.new
+      set_new_breadcrumb_buffer
     end
 
     def dup
@@ -171,7 +172,6 @@ module Sentry
     private
 
     def set_default_value
-      @breadcrumbs = BreadcrumbBuffer.new
       @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }
       @extra = {}
       @tags = {}
@@ -182,8 +182,14 @@ module Sentry
       @event_processors = []
       @rack_env = {}
       @span = nil
+      set_new_breadcrumb_buffer
     end
 
+    def set_new_breadcrumb_buffer
+      @breadcrumbs = BreadcrumbBuffer.new(@max_breadcrumbs)
+    end
+
+
     class << self
       def os_context
         @os_context ||=

data/lib/sentry/transaction.rb

@@ -25,14 +25,20 @@ module Sentry
       @span_recorder.add(self)
     end
 
-    def self.from_sentry_trace(sentry_trace, **options)
+    def self.from_sentry_trace(sentry_trace, configuration: Sentry.configuration, **options)
+      return unless configuration.tracing_enabled?
       return unless sentry_trace
 
       match = SENTRY_TRACE_REGEXP.match(sentry_trace)
       return if match.nil?
       trace_id, parent_span_id, sampled_flag = match[1..3]
 
-      sampled = sampled_flag != "0"
+      sampled =
+        if sampled_flag.nil?
+          nil
+        else
+          sampled_flag != "0"
+        end
 
       new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: sampled, sampled: sampled, **options)
     end
@@ -67,8 +73,8 @@ module Sentry
       copy
     end
 
-    def set_initial_sample_desicion(sampling_context = {})
-      unless Sentry.configuration.tracing_enabled?
+    def set_initial_sample_decision(sampling_context: {}, configuration: Sentry.configuration)
+      unless configuration.tracing_enabled?
         @sampled = false
         return
       end
@@ -77,9 +83,9 @@ module Sentry
 
       transaction_description = generate_transaction_description
 
-      logger = Sentry.configuration.logger
-      sample_rate = Sentry.configuration.traces_sample_rate
-      traces_sampler = Sentry.configuration.traces_sampler
+      logger = configuration.logger
+      sample_rate = configuration.traces_sample_rate
+      traces_sampler = configuration.traces_sampler
 
       if traces_sampler.is_a?(Proc)
         sampling_context = sampling_context.merge(

data/lib/sentry/transport.rb

@@ -31,9 +31,6 @@ module Sentry
       send_data(encoded_data)
 
       event
-    rescue => e
-      failed_for_exception(e, event)
-      nil
     end
 
     def generate_auth_header
@@ -72,15 +69,6 @@ module Sentry
       configuration.logger.info(LOGGER_PROGNAME) { "Sending #{event_type} #{event_id} to Sentry" }
       encode(event_hash)
     end
-
-    def failed_for_exception(e, event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}" }
-      log_not_sending(event)
-    end
-
-    def log_not_sending(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event. Unreported Event: #{Event.get_log_message(event.to_hash)}" }
-    end
   end
 end
 

data/lib/sentry/transport/configuration.rb

@@ -1,12 +1,14 @@
 module Sentry
   class Transport
     class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder, :transport_class
+      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder,
+        :transport_class, :encoding
 
       def initialize
         @ssl_verification = true
         @open_timeout = 1
         @timeout = 2
+        @encoding = HTTPTransport::GZIP_ENCODING
       end
 
       def transport_class=(klass)

data/lib/sentry/transport/http_transport.rb

@@ -1,8 +1,12 @@
 require 'faraday'
+require 'zlib'
 
 module Sentry
   class HTTPTransport < Transport
-    CONTENT_TYPE = 'application/json'
+    GZIP_ENCODING = "gzip"
+    GZIP_THRESHOLD = 1024 * 30
+    CONTENT_TYPE = 'application/x-sentry-envelope'
+
     attr_reader :conn, :adapter
 
     def initialize(*args)
@@ -13,8 +17,16 @@ module Sentry
     end
 
     def send_data(data)
+      encoding = ""
+
+      if should_compress?(data)
+        data = Zlib.gzip(data)
+        encoding = GZIP_ENCODING
+      end
+
       conn.post @endpoint do |req|
         req.headers['Content-Type'] = CONTENT_TYPE
+        req.headers['Content-Encoding'] = encoding
         req.headers['X-Sentry-Auth'] = generate_auth_header
         req.body = data
       end
@@ -26,11 +38,15 @@ module Sentry
         error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}" if e.response[:headers]['x-sentry-error']
       end
 
-      raise Sentry::Error, error_info
+      raise Sentry::ExternalError, error_info
     end
 
     private
 
+    def should_compress?(data)
+      @transport_configuration.encoding == GZIP_ENCODING && data.bytesize >= GZIP_THRESHOLD
+    end
+
     def set_conn
       server = @dsn.server
 

data/lib/sentry/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "4.2.2"
+  VERSION = "4.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.3.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-18 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -71,6 +71,7 @@ files:
 - lib/sentry/core_ext/object/duplicable.rb
 - lib/sentry/dsn.rb
 - lib/sentry/event.rb
+- lib/sentry/exceptions.rb
 - lib/sentry/hub.rb
 - lib/sentry/integrable.rb
 - lib/sentry/interface.rb
@@ -78,6 +79,7 @@ files:
 - lib/sentry/interfaces/request.rb
 - lib/sentry/interfaces/single_exception.rb
 - lib/sentry/interfaces/stacktrace.rb
+- lib/sentry/interfaces/stacktrace_builder.rb
 - lib/sentry/interfaces/threads.rb
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb