sentry-ruby 4.0.1 → 4.1.4

data/lib/sentry/interfaces/stacktrace.rb

@@ -1,11 +1,31 @@
 module Sentry
-  class StacktraceInterface < Interface
-    attr_accessor :frames
+  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
+    end
 
     def to_hash
-      data = super
-      data[:frames] = data[:frames].map(&:to_hash)
-      data
+      { frames: @frames.map(&:to_hash) }
+    end
+
+    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
@@ -13,8 +33,14 @@ module Sentry
       attr_accessor :abs_path, :context_line, :function, :in_app,
                     :lineno, :module, :pre_context, :post_context, :vars
 
-      def initialize(project_root)
+      def initialize(project_root, line)
         @project_root = project_root
+
+        @abs_path = line.file if line.file
+        @function = line.method if line.method
+        @lineno = line.number
+        @in_app = line.in_app
+        @module = line.module_name if line.module_name
       end
 
       def filename
@@ -33,6 +59,13 @@ module Sentry
         @filename = 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 = \
+            linecache.get_file_context(abs_path, lineno, context_lines)
+      end
+
       def to_hash(*args)
         data = super(*args)
         data[:filename] = filename

data/lib/sentry/rack.rb

@@ -1,5 +1,4 @@
-require 'time'
 require 'rack'
 
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'
+require 'sentry/rack/capture_exceptions'
+require 'sentry/rack/deprecations'

data/lib/sentry/rack/capture_exceptions.rb

@@ -0,0 +1,68 @@
+module Sentry
+  module Rack
+    class CaptureExceptions
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless Sentry.initialized?
+
+        # make sure the current thread has a clean hub
+        Sentry.clone_hub_to_current_thread
+
+        Sentry.with_scope do |scope|
+          scope.clear_breadcrumbs
+          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+          scope.set_rack_env(env)
+
+          span =
+            if sentry_trace = env["sentry-trace"]
+              Sentry::Transaction.from_sentry_trace(sentry_trace, name: scope.transaction_name, op: transaction_op)
+            else
+              Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
+            end
+
+          scope.set_span(span)
+
+          begin
+            response = @app.call(env)
+          rescue Sentry::Error
+            finish_span(span, 500)
+            raise # Don't capture Sentry errors
+          rescue Exception => e
+            capture_exception(e)
+            finish_span(span, 500)
+            raise
+          end
+
+          exception = collect_exception(env)
+          capture_exception(exception) if exception
+
+          finish_span(span, response[0])
+
+          response
+        end
+      end
+
+      private
+
+      def collect_exception(env)
+        env['rack.exception'] || env['sinatra.error']
+      end
+
+      def transaction_op
+        "rack.request".freeze
+      end
+
+      def capture_exception(exception)
+        Sentry.capture_exception(exception)
+      end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
+    end
+  end
+end

data/lib/sentry/rack/deprecations.rb

@@ -0,0 +1,19 @@
+module Sentry
+  module Rack
+    class DeprecatedMiddleware
+      def initialize(_)
+        raise Sentry::Error.new <<~MSG
+
+You're seeing this message because #{self.class} has been replaced by Sentry::Rack::CaptureExceptions.
+Removing this middleware from your app and upgrading sentry-rails to 4.1.0+ should solve the issue.
+        MSG
+      end
+    end
+
+    class Tracing < DeprecatedMiddleware
+    end
+
+    class CaptureException < DeprecatedMiddleware
+    end
+  end
+end

data/lib/sentry/rake.rb

@@ -5,11 +5,11 @@ module Rake
   class Application
     alias orig_display_error_messsage display_error_message
     def display_error_message(ex)
-      Sentry.capture_exception(ex) do |scope|
+      Sentry.capture_exception(ex, hint: { background: false }) do |scope|
         task_name = top_level_tasks.join(' ')
         scope.set_transaction_name(task_name)
         scope.set_tag("rake_task", task_name)
-      end
+      end if Sentry.initialized?
 
       orig_display_error_messsage(ex)
     end

data/lib/sentry/scope.rb

@@ -3,6 +3,8 @@ require "etc"
 
 module Sentry
   class Scope
+    include ArgumentCheckingHelper
+
     ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span]
 
     attr_reader(*ATTRIBUTES)
@@ -29,7 +31,7 @@ module Sentry
       event.level = level
       event.transaction = transaction_names.last
       event.breadcrumbs = breadcrumbs
-      event.rack_env = rack_env
+      event.rack_env = rack_env if rack_env
 
       unless @event_processors.empty?
         @event_processors.each do |processor_block|
@@ -57,7 +59,7 @@ module Sentry
       copy.user = user.deep_dup
       copy.transaction_names = transaction_names.deep_dup
       copy.fingerprint = fingerprint.deep_dup
-      copy.span = span
+      copy.span = span.deep_dup
       copy
     end
 
@@ -168,12 +170,6 @@ module Sentry
 
     private
 
-    def check_argument_type!(argument, expected_type)
-      unless argument.is_a?(expected_type)
-        raise ArgumentError, "expect the argument to be a #{expected_type}, got #{argument.class} (#{argument})"
-      end
-    end
-
     def set_default_value
       @breadcrumbs = BreadcrumbBuffer.new
       @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }

data/lib/sentry/span.rb

@@ -35,11 +35,6 @@ module Sentry
       @tags = {}
     end
 
-    def set_span_recorder
-      @span_recorder = SpanRecorder.new(1000)
-      @span_recorder.add(self)
-    end
-
     def finish
       # already finished
       return if @timestamp
@@ -74,6 +69,7 @@ module Sentry
       {
         trace_id: @trace_id,
         span_id: @span_id,
+        parent_span_id: @parent_span_id,
         description: @description,
         op: @op,
         status: @status
@@ -82,14 +78,7 @@ module Sentry
 
     def start_child(**options)
       options = options.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
-      child_span = Span.new(options)
-      child_span.span_recorder = @span_recorder
-
-      if @span_recorder && @sampled
-        @span_recorder.add(child_span)
-      end
-
-      child_span
+      Span.new(**options)
     end
 
     def with_child_span(**options, &block)
@@ -100,6 +89,10 @@ module Sentry
       child_span.finish
     end
 
+    def deep_dup
+      dup
+    end
+
     def set_op(op)
       @op = op
     end
@@ -136,20 +129,5 @@ module Sentry
     def set_tag(key, value)
       @tags[key] = value
     end
-
-    class SpanRecorder
-      attr_reader :max_length, :spans
-
-      def initialize(max_length)
-        @max_length = max_length
-        @spans = []
-      end
-
-      def add(span)
-        if @spans.count < @max_length
-          @spans << span
-        end
-      end
-    end
   end
 end

data/lib/sentry/transaction.rb

@@ -20,6 +20,11 @@ module Sentry
       set_span_recorder
     end
 
+    def set_span_recorder
+      @span_recorder = SpanRecorder.new(1000)
+      @span_recorder.add(self)
+    end
+
     def self.from_sentry_trace(sentry_trace, **options)
       return unless sentry_trace
 
@@ -37,6 +42,30 @@ module Sentry
       hash
     end
 
+    def start_child(**options)
+      child_span = super
+      child_span.span_recorder = @span_recorder
+
+      if @sampled
+        @span_recorder.add(child_span)
+      end
+
+      child_span
+    end
+
+    def deep_dup
+      copy = super
+      copy.set_span_recorder
+
+      @span_recorder.spans.each do |span|
+        # span_recorder's first span is the current span, which should not be added to the copy's spans
+        next if span == self
+        copy.span_recorder.add(span.dup)
+      end
+
+      copy
+    end
+
     def set_initial_sample_desicion(sampling_context = {})
       unless Sentry.configuration.tracing_enabled?
         @sampled = false
@@ -94,7 +123,7 @@ module Sentry
         @name = UNLABELD_NAME
       end
 
-      return unless @sampled
+      return unless @sampled || @parent_sampled
 
       hub ||= Sentry.get_current_hub
       event = hub.current_client.event_from_transaction(self)
@@ -109,5 +138,20 @@ module Sentry
       result += " <#{@name}>" if @name
       result
     end
+
+    class SpanRecorder
+      attr_reader :max_length, :spans
+
+      def initialize(max_length)
+        @max_length = max_length
+        @spans = []
+      end
+
+      def add(span)
+        if @spans.count < @max_length
+          @spans << span
+        end
+      end
+    end
   end
 end

data/lib/sentry/transport.rb

@@ -1,20 +1,17 @@
 require "json"
 require "base64"
-require "sentry/transport/state"
 
 module Sentry
   class Transport
     PROTOCOL_VERSION = '5'
     USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
-    CONTENT_TYPE = 'application/json'
 
-    attr_accessor :configuration, :state
+    attr_accessor :configuration
 
     def initialize(configuration)
       @configuration = configuration
       @transport_configuration = configuration.transport
       @dsn = configuration.dsn
-      @state = State.new
     end
 
     def send_data(data, options = {})
@@ -22,13 +19,17 @@ module Sentry
     end
 
     def send_event(event)
-      content_type, encoded_data = prepare_encoded_event(event)
+      unless configuration.sending_allowed?
+        configuration.logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
+        return
+      end
+
+      encoded_data = prepare_encoded_event(event)
 
       return nil unless encoded_data
 
-      send_data(encoded_data, content_type: content_type)
+      send_data(encoded_data)
 
-      state.success
       event
     rescue => e
       failed_for_exception(e, event)
@@ -57,7 +58,7 @@ module Sentry
         #{JSON.generate(event_hash)}
       ENVELOPE
 
-      [CONTENT_TYPE, envelope]
+      envelope
     end
 
     private
@@ -66,27 +67,17 @@ module Sentry
       # Convert to hash
       event_hash = event.to_hash
 
-      unless @state.should_try?
-        failed_for_previous_failure(event_hash)
-        return
-      end
-
-      event_id = event_hash[:event_id] || event_hash['event_id']
-      configuration.logger.info(LOGGER_PROGNAME) { "Sending event #{event_id} to Sentry" }
+      event_id = event_hash[:event_id] || event_hash["event_id"]
+      event_type = event_hash[:type] || event_hash["type"]
+      configuration.logger.info(LOGGER_PROGNAME) { "Sending #{event_type} #{event_id} to Sentry" }
       encode(event_hash)
     end
 
     def failed_for_exception(e, event)
-      @state.failure
       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 failed_for_previous_failure(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Not sending event due to previous failure(s)." }
-      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

data/lib/sentry/transport/http_transport.rb

@@ -2,6 +2,7 @@ require 'faraday'
 
 module Sentry
   class HTTPTransport < Transport
+    CONTENT_TYPE = 'application/json'
     attr_reader :conn, :adapter
 
     def initialize(*args)
@@ -11,13 +12,9 @@ module Sentry
       @endpoint = @dsn.envelope_endpoint
     end
 
-    def send_data(data, options = {})
-      unless configuration.sending_allowed?
-        logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
-      end
-
+    def send_data(data)
       conn.post @endpoint do |req|
-        req.headers['Content-Type'] = options[:content_type]
+        req.headers['Content-Type'] = CONTENT_TYPE
         req.headers['X-Sentry-Auth'] = generate_auth_header
         req.body = data
       end