sentry-ruby 0.1.1

data/lib/sentry/hub.rb

@@ -0,0 +1,126 @@
+require "sentry/scope"
+require "sentry/client"
+
+module Sentry
+  class Hub
+    attr_reader :last_event_id
+
+    def initialize(client, scope)
+      first_layer = Layer.new(client, scope)
+      @stack = [first_layer]
+      @last_event_id = nil
+    end
+
+    def new_from_top
+      Hub.new(current_client, current_scope)
+    end
+
+    def current_client
+      current_layer&.client
+    end
+
+    def current_scope
+      current_layer&.scope
+    end
+
+    def clone
+      layer = current_layer
+
+      if layer
+        scope = layer.scope&.dup
+
+        Hub.new(layer.client, scope)
+      end
+    end
+
+    def bind_client(client)
+      layer = current_layer
+
+      if layer
+        layer.client = client
+      end
+    end
+
+    def configure_scope(&block)
+      block.call(current_scope)
+    end
+
+    def with_scope(&block)
+      push_scope
+      yield(current_scope)
+    ensure
+      pop_scope
+    end
+
+    def push_scope
+      new_scope =
+        if current_scope
+          current_scope.dup
+        else
+          Scope.new
+        end
+
+      @stack << Layer.new(current_client, new_scope)
+    end
+
+    def pop_scope
+      @stack.pop
+    end
+
+    def capture_exception(exception, **options, &block)
+      return unless current_client
+
+      event = current_client.event_from_exception(exception)
+
+      return unless event
+
+      capture_event(event, **options, &block)
+    end
+
+    def capture_message(message, **options, &block)
+      return unless current_client
+
+      event = current_client.event_from_message(message)
+      capture_event(event, **options, &block)
+    end
+
+    def capture_event(event, **options, &block)
+      return unless current_client
+
+      scope = current_scope.dup
+
+      if block
+        block.call(scope)
+      elsif custom_scope = options[:scope]
+        scope.update_from_scope(custom_scope)
+      elsif !options.empty?
+        scope.update_from_options(**options)
+      end
+
+      event = current_client.capture_event(event, scope)
+
+      @last_event_id = event.id
+      event
+    end
+
+    def add_breadcrumb(breadcrumb)
+      current_scope.add_breadcrumb(breadcrumb)
+    end
+
+    private
+
+    def current_layer
+      @stack.last
+    end
+
+    class Layer
+      attr_accessor :client
+      attr_reader :scope
+
+      def initialize(client, scope)
+        @client = client
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/sentry/interface.rb

@@ -0,0 +1,22 @@
+module Sentry
+  class Interface
+    def self.inherited(klass)
+      name = klass.name.split("::").last.downcase.gsub("interface", "")
+      registered[name.to_sym] = klass
+      super
+    end
+
+    def self.registered
+      @@registered ||= {} # rubocop:disable Style/ClassVars
+    end
+
+    def to_hash
+      Hash[instance_variables.map { |name| [name[1..-1].to_sym, instance_variable_get(name)] }]
+    end
+  end
+end
+
+require "sentry/interfaces/exception"
+require "sentry/interfaces/request"
+require "sentry/interfaces/single_exception"
+require "sentry/interfaces/stacktrace"

data/lib/sentry/interfaces/exception.rb

@@ -0,0 +1,11 @@
+module Sentry
+  class ExceptionInterface < Interface
+    attr_accessor :values
+
+    def to_hash
+      data = super
+      data[:values] = data[:values].map(&:to_hash) if data[:values]
+      data
+    end
+  end
+end

data/lib/sentry/interfaces/request.rb

@@ -0,0 +1,104 @@
+require 'rack'
+
+module Sentry
+  class RequestInterface < Interface
+    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+    IP_HEADERS = [
+      "REMOTE_ADDR",
+      "HTTP_CLIENT_IP",
+      "HTTP_X_REAL_IP",
+      "HTTP_X_FORWARDED_FOR"
+    ].freeze
+
+    attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
+
+    def initialize
+      self.headers = {}
+      self.env = {}
+      self.cookies = nil
+    end
+
+    def from_rack(env_hash)
+      req = ::Rack::Request.new(env_hash)
+
+      if Sentry.configuration.send_default_pii
+        self.data = read_data_from(req)
+        self.cookies = req.cookies
+      else
+        # need to completely wipe out ip addresses
+        IP_HEADERS.each { |h| env_hash.delete(h) }
+      end
+
+      self.url = req.scheme && req.url.split('?').first
+      self.method = req.request_method
+      self.query_string = req.query_string
+
+      self.headers = format_headers_for_sentry(env_hash)
+      self.env     = format_env_for_sentry(env_hash)
+    end
+
+    private
+
+    # Request ID based on ActionDispatch::RequestId
+    def read_request_id_from(env_hash)
+      REQUEST_ID_HEADERS.each do |key|
+        request_id = env_hash[key]
+        return request_id if request_id
+      end
+      nil
+    end
+
+    # See Sentry server default limits at
+    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
+    def read_data_from(request)
+      if request.form_data?
+        request.POST
+      elsif request.body # JSON requests, etc
+        data = request.body.read(4096 * 4) # Sentry server limit
+        request.body.rewind
+        data
+      end
+    rescue IOError => e
+      e.message
+    end
+
+    def format_headers_for_sentry(env_hash)
+      env_hash.each_with_object({}) do |(key, value), memo|
+        begin
+          key = key.to_s # rack env can contain symbols
+          value = value.to_s
+          next memo['X-Request-Id'] ||= read_request_id_from(env_hash) if REQUEST_ID_HEADERS.include?(key)
+          next unless key.upcase == key # Non-upper case stuff isn't either
+
+          # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
+          # to think this is a Version header. Instead, this is mapped to
+          # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
+          # if the request has legitimately sent a Version header themselves.
+          # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
+          next if key == 'HTTP_VERSION' && value == env_hash['SERVER_PROTOCOL']
+          next if key == 'HTTP_COOKIE' # Cookies don't go here, they go somewhere else
+          next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(key)
+
+          # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
+          key = key.sub(/^HTTP_/, "")
+          key = key.split('_').map(&:capitalize).join('-')
+          memo[key] = value
+        rescue StandardError => e
+          # Rails adds objects to the Rack env that can sometimes raise exceptions
+          # when `to_s` is called.
+          # See: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb#L134
+          Sentry.logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
+          next
+        end
+      end
+    end
+
+    def format_env_for_sentry(env_hash)
+      return env_hash if Sentry.configuration.rack_env_whitelist.empty?
+
+      env_hash.select do |k, _v|
+        Sentry.configuration.rack_env_whitelist.include? k.to_s
+      end
+    end
+  end
+end

data/lib/sentry/interfaces/single_exception.rb

@@ -0,0 +1,14 @@
+module Sentry
+  class SingleExceptionInterface < Interface
+    attr_accessor :type
+    attr_accessor :value
+    attr_accessor :module
+    attr_accessor :stacktrace
+
+    def to_hash
+      data = super
+      data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
+      data
+    end
+  end
+end

data/lib/sentry/interfaces/stacktrace.rb

@@ -0,0 +1,57 @@
+module Sentry
+  class StacktraceInterface < Interface
+    attr_accessor :frames
+
+    def to_hash
+      data = super
+      data[:frames] = data[:frames].map(&:to_hash)
+      data
+    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
+
+      def initialize(project_root)
+        @project_root = project_root
+      end
+
+      def filename
+        return if abs_path.nil?
+        return @filename if instance_variable_defined?(:@filename)
+
+        prefix =
+          if under_project_root? && in_app
+            @project_root
+          elsif under_project_root?
+            longest_load_path || @project_root
+          else
+            longest_load_path
+          end
+
+        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+      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.delete(:context_line) unless context_line && !context_line.empty?
+        data
+      end
+
+      private
+
+      def under_project_root?
+        @project_root && abs_path.start_with?(@project_root)
+      end
+
+      def longest_load_path
+        $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
+      end
+    end
+  end
+end

data/lib/sentry/linecache.rb

@@ -0,0 +1,44 @@
+module Sentry
+  class LineCache
+    def initialize
+      @cache = {}
+    end
+
+    # Any linecache you provide to Sentry must implement this method.
+    # Returns an Array of Strings representing the lines in the source
+    # file. The number of lines retrieved is (2 * context) + 1, the middle
+    # line should be the line requested by lineno. See specs for more information.
+    def get_file_context(filename, lineno, context)
+      return nil, nil, nil unless valid_path?(filename)
+
+      lines = Array.new(2 * context + 1) do |i|
+        getline(filename, lineno - context + i)
+      end
+      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
+    end
+
+    private
+
+    def valid_path?(path)
+      lines = getlines(path)
+      !lines.nil?
+    end
+
+    def getlines(path)
+      @cache[path] ||= begin
+        IO.readlines(path)
+                       rescue
+                         nil
+      end
+    end
+
+    def getline(path, n)
+      return nil if n < 1
+
+      lines = getlines(path)
+      return nil if lines.nil?
+
+      lines[n - 1]
+    end
+  end
+end

data/lib/sentry/logger.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Sentry
+  class Logger < ::Logger
+    LOG_PREFIX = "** [Sentry] "
+    PROGNAME   = "sentry"
+
+    def initialize(*)
+      super
+      @level = ::Logger::INFO
+      original_formatter = ::Logger::Formatter.new
+      @default_formatter = proc do |severity, datetime, _progname, msg|
+        msg = "#{LOG_PREFIX}#{msg}"
+        original_formatter.call(severity, datetime, PROGNAME, msg)
+      end
+    end
+  end
+end

data/lib/sentry/rack.rb

@@ -0,0 +1,4 @@
+require 'time'
+require 'rack'
+
+require 'sentry/rack/capture_exception'

data/lib/sentry/rack/capture_exception.rb

@@ -0,0 +1,45 @@
+module Sentry
+  module Rack
+    class CaptureException
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # this call clones the main (global) hub
+        # and assigns it to the current thread's Sentry#get_current_hub
+        # it's essential for multi-thread servers (e.g. puma)
+        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
+        # this call creates an isolated scope for every request
+        # it's essential for multi-process servers (e.g. unicorn)
+        Sentry.with_scope do |scope|
+          # there could be some breadcrumbs already stored in the top-level scope
+          # and for request information, we don't need those breadcrumbs
+          scope.clear_breadcrumbs
+          env['sentry.client'] = Sentry.get_current_client
+
+          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+          scope.set_rack_env(env)
+
+          begin
+            response = @app.call(env)
+          rescue Sentry::Error
+            raise # Don't capture Sentry errors
+          rescue Exception => e
+            Sentry.capture_exception(e)
+            raise
+          end
+
+          exception = collect_exception(env)
+          Sentry.capture_exception(exception) if exception
+
+          response
+        end
+      end
+
+      def collect_exception(env)
+        env['rack.exception'] || env['sinatra.error']
+      end
+    end
+  end
+end