sentry-raven 3.0.1 → 3.1.1

data/sentry-ruby/lib/sentry/transports.rb

@@ -0,0 +1,19 @@
+module Sentry
+  module Transports
+    class Transport
+      attr_accessor :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def send_event # (auth_header, data, options = {})
+        raise NotImplementedError, 'Abstract method not implemented'
+      end
+    end
+  end
+end
+
+require "sentry/transports/dummy"
+require "sentry/transports/http"
+require "sentry/transports/stdout"

data/sentry-ruby/lib/sentry/transports/dummy.rb

@@ -0,0 +1,16 @@
+module Sentry
+  module Transports
+    class Dummy < Transport
+      attr_accessor :events
+
+      def initialize(*)
+        super
+        @events = []
+      end
+
+      def send_event(auth_header, data, options = {})
+        @events << [auth_header, data, options]
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/transports/http.rb

@@ -0,0 +1,66 @@
+require 'faraday'
+
+module Sentry
+  module Transports
+    class HTTP < Transport
+      attr_accessor :conn, :adapter
+
+      def initialize(*args)
+        super
+        self.adapter = configuration.http_adapter || Faraday.default_adapter
+        self.conn = set_conn
+      end
+
+      def send_event(auth_header, data, options = {})
+        unless configuration.sending_allowed?
+          logger.debug("Event not sent: #{configuration.error_messages}")
+        end
+
+        project_id = configuration[:project_id]
+        path = configuration[:path] + "/"
+
+        conn.post "#{path}api/#{project_id}/store/" do |req|
+          req.headers['Content-Type'] = options[:content_type]
+          req.headers['X-Sentry-Auth'] = auth_header
+          req.body = data
+        end
+      rescue Faraday::Error => e
+        error_info = e.message
+        if e.response && e.response[:headers]['x-sentry-error']
+          error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}"
+        end
+        raise Sentry::Error, error_info
+      end
+
+      private
+
+      def set_conn
+        configuration.logger.debug "Sentry HTTP Transport connecting to #{configuration.server}"
+
+        proxy = configuration.public_send(:proxy)
+
+        Faraday.new(configuration.server, :ssl => ssl_configuration, :proxy => proxy) do |builder|
+          configuration.faraday_builder&.call(builder)
+          builder.response :raise_error
+          builder.options.merge! faraday_opts
+          builder.headers[:user_agent] = "sentry-ruby/#{Sentry::VERSION}"
+          builder.adapter(*adapter)
+        end
+      end
+
+      # TODO: deprecate and replace where possible w/Faraday Builder
+      def faraday_opts
+        [:timeout, :open_timeout].each_with_object({}) do |opt, memo|
+          memo[opt] = configuration.public_send(opt) if configuration.public_send(opt)
+        end
+      end
+
+      def ssl_configuration
+        (configuration.ssl || {}).merge(
+          :verify => configuration.ssl_verification,
+          :ca_file => configuration.ssl_ca_file
+        )
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/transports/stdout.rb

@@ -0,0 +1,20 @@
+module Sentry
+  module Transports
+    class Stdout < Transport
+      attr_accessor :events
+
+      def initialize(*)
+        super
+      end
+
+      def send_event(_auth_header, data, _options = {})
+        unless configuration.sending_allowed?
+          logger.debug("Event not sent: #{configuration.error_messages}")
+        end
+
+        $stdout.puts data
+        $stdout.flush
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/utils/deep_merge.rb

@@ -0,0 +1,22 @@
+module Sentry
+  module Utils
+    # ported from ActiveSupport
+    module DeepMergeHash
+      def self.deep_merge(hash, other_hash, &block)
+        deep_merge!(hash, other_hash, &block)
+      end
+
+      def self.deep_merge!(hash, other_hash, &block)
+        hash.merge!(other_hash) do |key, this_val, other_val|
+          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+            deep_merge(this_val, other_val, &block)
+          elsif block_given?
+            block.call(key, this_val, other_val)
+          else
+            other_val
+          end
+        end
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/utils/exception_cause_chain.rb

@@ -0,0 +1,20 @@
+module Sentry
+  module Utils
+    module ExceptionCauseChain
+      def self.exception_to_array(exception)
+        if exception.respond_to?(:cause) && exception.cause
+          exceptions = [exception]
+          while exception.cause
+            exception = exception.cause
+            break if exceptions.any? { |e| e.object_id == exception.object_id }
+
+            exceptions << exception
+          end
+          exceptions
+        else
+          [exception]
+        end
+      end
+    end
+  end
+end

data/sentry-ruby/lib/sentry/version.rb

@@ -0,0 +1,3 @@
+module Sentry
+  VERSION = "0.1.0"
+end

data/sentry-ruby/sentry-ruby.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/sentry/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sentry-ruby"
+  spec.version       = Sentry::VERSION
+  spec.authors = ["Sentry Team"]
+  spec.description = spec.summary = "A gem that provides a client interface for the Sentry error logger"
+  spec.email = "accounts@sentry.io"
+  spec.license = 'Apache-2.0'
+  spec.homepage = "https://github.com/getsentry/raven-ruby"
+
+  spec.platform = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 2.4'
+  spec.extra_rdoc_files = ["README.md", "LICENSE"]
+  spec.files = `git ls-files | grep -Ev '^(spec|benchmarks|examples)'`.split("\n")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", ">= 1.0"
+end

data/sentry-ruby/spec/sentry/backtrace_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe Sentry::Backtrace do
+  let(:configuration) { Sentry::Configuration.new }
+
+  before(:each) do
+    @backtrace = Sentry::Backtrace.parse(Thread.current.backtrace, configuration: configuration)
+  end
+
+  it "calls backtrace_cleanup_callback if it's present in the configuration" do
+    called = false
+    callback = proc do |backtrace|
+      called = true
+      backtrace
+    end
+    configuration.backtrace_cleanup_callback = callback
+    Sentry::Backtrace.parse(Thread.current.backtrace, configuration: configuration)
+
+    expect(called).to eq(true)
+  end
+
+  it "#lines" do
+    expect(@backtrace.lines.first).to be_a(Sentry::Backtrace::Line)
+  end
+
+  it "#inspect" do
+    expect(@backtrace.inspect).to match(/Backtrace: .*>$/)
+  end
+
+  it "#to_s" do
+    expect(@backtrace.to_s).to match(/backtrace_spec.rb:\d/)
+  end
+
+  it "==" do
+    @backtrace2 = Sentry::Backtrace.new(@backtrace.lines)
+    expect(@backtrace).to be == @backtrace2
+  end
+end

data/sentry-ruby/spec/sentry/client_spec.rb

@@ -0,0 +1,443 @@
+require 'spec_helper'
+
+class ExceptionWithContext < StandardError
+  def sentry_context
+    { extra: {
+      'context_event_key' => 'context_value',
+      'context_key' => 'context_value'
+    } }
+  end
+end
+
+RSpec.describe Sentry::Client do
+  let(:configuration) do
+    Sentry::Configuration.new.tap do |config|
+      config.server = 'http://12345:67890@sentry.localdomain/sentry/42'
+    end
+  end
+  let(:fake_time) { Time.now }
+
+  subject { Sentry::Client.new(configuration) }
+
+  before do
+    allow(Time).to receive(:now).and_return fake_time
+  end
+
+  describe "#generate_auth_header" do
+    it "generates an auth header" do
+      expect(subject.send(:generate_auth_header)).to eq(
+        "Sentry sentry_version=5, sentry_client=sentry-ruby/#{Sentry::VERSION}, sentry_timestamp=#{fake_time.to_i}, " \
+        "sentry_key=12345, sentry_secret=67890"
+      )
+    end
+
+    it "generates an auth header without a secret (Sentry 9)" do
+      configuration.server = "https://66260460f09b5940498e24bb7ce093a0@sentry.io/42"
+
+      expect(subject.send(:generate_auth_header)).to eq(
+        "Sentry sentry_version=5, sentry_client=sentry-ruby/#{Sentry::VERSION}, sentry_timestamp=#{fake_time.to_i}, " \
+        "sentry_key=66260460f09b5940498e24bb7ce093a0"
+      )
+    end
+  end
+
+  describe "#send_event" do
+    let(:event) { subject.event_from_exception(ZeroDivisionError.new("divided by 0")) }
+
+    context "when success" do
+      before do
+        allow(subject.transport).to receive(:send_event)
+      end
+
+      it "sends Event object" do
+        expect(subject).not_to receive(:failed_send)
+
+        expect(subject.send_event(event)).to eq(event.to_hash)
+      end
+
+      it "sends Event hash" do
+        expect(subject).not_to receive(:failed_send)
+
+        expect(subject.send_event(event.to_json_compatible)).to eq(event.to_json_compatible)
+      end
+    end
+
+    context "when failed" do
+      let(:logger) { spy }
+
+      before do
+        configuration.logger = logger
+        allow(subject.transport).to receive(:send_event).and_raise(StandardError)
+
+        expect(logger).to receive(:warn).exactly(2)
+      end
+
+      it "sends Event object" do
+        expect(subject.send_event(event)).to eq(nil)
+      end
+
+      it "sends Event hash" do
+        expect(subject.send_event(event.to_json_compatible)).to eq(nil)
+      end
+    end
+  end
+
+  describe "#transport" do
+    context "when scheme is not set" do
+      it "returns HTTP transport object" do
+        expect(subject.transport).to be_a(Sentry::Transports::HTTP)
+      end
+    end
+
+    context "when scheme is http" do
+      before do
+        configuration.scheme = "http"
+      end
+
+      it "returns HTTP transport object" do
+        expect(subject.transport).to be_a(Sentry::Transports::HTTP)
+      end
+    end
+
+    context "when scheme is https" do
+      before do
+        configuration.scheme = "https"
+      end
+
+      it "returns HTTP transport object" do
+        expect(subject.transport).to be_a(Sentry::Transports::HTTP)
+      end
+    end
+
+    context "when scheme is dummy" do
+      before do
+        configuration.scheme = "dummy"
+      end
+
+      it "returns Dummy transport object" do
+        expect(subject.transport).to be_a(Sentry::Transports::Dummy)
+      end
+    end
+
+    context "when scheme is stdout" do
+      before do
+        configuration.scheme = "stdout"
+      end
+
+      it "returns Stdout transport object" do
+        expect(subject.transport).to be_a(Sentry::Transports::Stdout)
+      end
+    end
+  end
+
+  shared_examples "options" do
+    let(:options) do
+      {
+        checksum: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        release: '1.0',
+        fingerprint: ['{{ default }}', 'foo'],
+        backtrace: ["/path/to/some/file:22:in `function_name'", "/some/other/path:1412:in `other_function'"]
+      }
+    end
+
+    let(:event) do
+      subject.event_from_exception(Exception.new, **options)
+    end
+
+    it 'takes and sets all available options' do
+      expect(event.checksum).to eq('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+      expect(event.release).to eq('1.0')
+      expect(event.fingerprint).to eq(['{{ default }}', 'foo'])
+    end
+
+    it "contains given backtrace" do
+      expect(event[:stacktrace]).to be_a(Sentry::StacktraceInterface)
+
+      frames = event[:stacktrace].to_hash[:frames]
+      expect(frames.length).to eq(2)
+      expect(frames[0][:lineno]).to eq(1412)
+      expect(frames[0][:function]).to eq('other_function')
+      expect(frames[0][:filename]).to eq('/some/other/path')
+
+      expect(frames[1][:lineno]).to eq(22)
+      expect(frames[1][:function]).to eq('function_name')
+      expect(frames[1][:filename]).to eq('/path/to/some/file')
+    end
+  end
+
+  describe '#event_from_message' do
+    let(:message) { 'This is a message' }
+
+    it 'returns an event' do
+      event = subject.event_from_message(message)
+      hash = event.to_hash
+
+      expect(event).to be_a(Sentry::Event)
+      expect(hash[:message]).to eq(message)
+      expect(hash[:level]).to eq(:error)
+    end
+
+    it "doesn't change the option hash" do
+      h_int = { abc: :abc }
+      h = { k1: h_int, k2: h_int }
+      subject.event_from_message "Test extra", extra: { h1: h, h2: h_int }
+
+      expect(h).to eq({ k1: h_int, k2: h_int })
+    end
+
+    it_behaves_like "options"
+  end
+
+  describe "#event_from_exception" do
+    let(:message) { 'This is a message' }
+    let(:exception) { Exception.new(message) }
+    let(:event) { subject.event_from_exception(exception) }
+    let(:hash) { event.to_hash }
+
+    before do
+      configuration.scheme = "dummy"
+    end
+
+    it "sets the message to the exception's value and type" do
+      expect(hash[:exception][:values][0][:type]).to eq("Exception")
+      expect(hash[:exception][:values][0][:value]).to eq(message)
+    end
+
+    it 'has level ERROR' do
+      expect(hash[:level]).to eq(:error)
+    end
+
+    it 'does not belong to a module' do
+      expect(hash[:exception][:values][0][:module]).to eq('')
+    end
+
+    it 'returns an event' do
+      event = subject.event_from_exception(ZeroDivisionError.new("divided by 0"))
+      expect(event).to be_a(Sentry::Event)
+      expect(subject.send(:get_message_from_exception, event.to_hash)).to eq("ZeroDivisionError: divided by 0")
+    end
+
+    it_behaves_like "options"
+
+    describe "options - message" do
+      it "proceses string message correctly" do
+        event = subject.event_from_exception(ExceptionWithContext.new, message: "MSG")
+        expect(event.message).to eq("MSG")
+      end
+
+      it "slices long string message" do
+        event = subject.event_from_exception(ExceptionWithContext.new, message: "MSG" * 3000)
+        expect(event.message.length).to eq(8192)
+      end
+
+      it "converts non-string message into string" do
+        expect(configuration.logger).to receive(:debug).with("You're passing a non-string message")
+
+        event = subject.event_from_exception(ExceptionWithContext.new, message: { foo: "bar" })
+        expect(event.message).to eq("{:foo=>\"bar\"}")
+      end
+    end
+
+    context 'for a nested exception type' do
+      module Sentry::Test
+        class Exception < RuntimeError; end
+      end
+      let(:exception) { Sentry::Test::Exception.new(message) }
+
+      it 'sends the module name as part of the exception info' do
+        expect(hash[:exception][:values][0][:module]).to eq('Sentry::Test')
+      end
+    end
+
+    describe "exception types test" do
+      context 'for a Sentry::Error' do
+        let(:exception) { Sentry::Error.new }
+        it 'does not create an event' do
+          expect(subject.event_from_exception(exception)).to be_nil
+        end
+      end
+
+      context 'for an excluded exception type' do
+        module Sentry::Test
+          class BaseExc < RuntimeError; end
+          class SubExc < BaseExc; end
+          module ExcTag; end
+        end
+
+        let(:config) { subject.configuration }
+
+        context "invalid exclusion type" do
+          it 'returns Sentry::Event' do
+            config.excluded_exceptions << nil
+            config.excluded_exceptions << 1
+            config.excluded_exceptions << {}
+            expect(subject.event_from_exception(Sentry::Test::BaseExc.new)).to be_a(Sentry::Event)
+          end
+        end
+
+        context "defined by string type" do
+          it 'returns nil for a class match' do
+            config.excluded_exceptions << 'Sentry::Test::BaseExc'
+            expect(subject.event_from_exception(Sentry::Test::BaseExc.new)).to be_nil
+          end
+
+          it 'returns nil for a top class match' do
+            config.excluded_exceptions << '::Sentry::Test::BaseExc'
+            expect(subject.event_from_exception(Sentry::Test::BaseExc.new)).to be_nil
+          end
+
+          it 'returns nil for a sub class match' do
+            config.excluded_exceptions << 'Sentry::Test::BaseExc'
+            expect(subject.event_from_exception(Sentry::Test::SubExc.new)).to be_nil
+          end
+
+          it 'returns nil for a tagged class match' do
+            config.excluded_exceptions << 'Sentry::Test::ExcTag'
+            expect(
+              subject.event_from_exception(Sentry::Test::SubExc.new.tap { |x| x.extend(Sentry::Test::ExcTag) })
+            ).to be_nil
+          end
+
+          it 'returns Sentry::Event for an undefined exception class' do
+            config.excluded_exceptions << 'Sentry::Test::NonExistentExc'
+            expect(subject.event_from_exception(Sentry::Test::BaseExc.new)).to be_a(Sentry::Event)
+          end
+        end
+
+        context "defined by class type" do
+          it 'returns nil for a class match' do
+            config.excluded_exceptions << Sentry::Test::BaseExc
+            expect(subject.event_from_exception(Sentry::Test::BaseExc.new)).to be_nil
+          end
+
+          it 'returns nil for a sub class match' do
+            config.excluded_exceptions << Sentry::Test::BaseExc
+            expect(subject.event_from_exception(Sentry::Test::SubExc.new)).to be_nil
+          end
+
+          it 'returns nil for a tagged class match' do
+            config.excluded_exceptions << Sentry::Test::ExcTag
+            expect(subject.event_from_exception(Sentry::Test::SubExc.new.tap { |x| x.extend(Sentry::Test::ExcTag) })).to be_nil
+          end
+        end
+      end
+
+      # Only check causes when they're supported
+      if Exception.new.respond_to? :cause
+        context 'when the exception has a cause' do
+          let(:exception) { build_exception_with_cause }
+
+          it 'captures the cause' do
+            expect(hash[:exception][:values].length).to eq(2)
+          end
+        end
+
+        context 'when the exception has nested causes' do
+          let(:exception) { build_exception_with_two_causes }
+
+          it 'captures nested causes' do
+            expect(hash[:exception][:values].length).to eq(3)
+          end
+        end
+      end
+
+      context 'when the exception has a recursive cause' do
+        let(:exception) { build_exception_with_recursive_cause }
+
+        it 'should handle it gracefully' do
+          expect(hash[:exception][:values].length).to eq(1)
+        end
+      end
+
+      if RUBY_PLATFORM == "java"
+        context 'when running under jRuby' do
+          let(:exception) do
+            begin
+              raise java.lang.OutOfMemoryError, "A Java error"
+            rescue Exception => e
+              return e
+            end
+          end
+
+          it 'should have a backtrace' do
+            frames = hash[:exception][:values][0][:stacktrace][:frames]
+            expect(frames.length).not_to eq(0)
+          end
+        end
+      end
+
+      context 'when the exception has a backtrace' do
+        let(:exception) do
+          e = Exception.new(message)
+          allow(e).to receive(:backtrace).and_return [
+            "/path/to/some/file:22:in `function_name'",
+            "/some/other/path:1412:in `other_function'"
+          ]
+          e
+        end
+
+        it 'parses the backtrace' do
+          frames = hash[:exception][:values][0][:stacktrace][:frames]
+          expect(frames.length).to eq(2)
+          expect(frames[0][:lineno]).to eq(1412)
+          expect(frames[0][:function]).to eq('other_function')
+          expect(frames[0][:filename]).to eq('/some/other/path')
+
+          expect(frames[1][:lineno]).to eq(22)
+          expect(frames[1][:function]).to eq('function_name')
+          expect(frames[1][:filename]).to eq('/path/to/some/file')
+        end
+
+        context 'with internal backtrace' do
+          let(:exception) do
+            e = Exception.new(message)
+            allow(e).to receive(:backtrace).and_return(["<internal:prelude>:10:in `synchronize'"])
+            e
+          end
+
+          it 'marks filename and in_app correctly' do
+            frames = hash[:exception][:values][0][:stacktrace][:frames]
+            expect(frames[0][:lineno]).to eq(10)
+            expect(frames[0][:function]).to eq("synchronize")
+            expect(frames[0][:filename]).to eq("<internal:prelude>")
+          end
+        end
+
+        context 'when a path in the stack trace is on the load path' do
+          before do
+            $LOAD_PATH << '/some'
+          end
+
+          after do
+            $LOAD_PATH.delete('/some')
+          end
+
+          it 'strips prefixes in the load path from frame filenames' do
+            frames = hash[:exception][:values][0][:stacktrace][:frames]
+            expect(frames[0][:filename]).to eq('other/path')
+          end
+        end
+      end
+
+      context 'merging exception context' do
+        let(:hash) do
+          event = subject.event_from_exception(
+            ExceptionWithContext.new,
+            message: "MSG",
+            extra: {
+              'context_event_key' => 'event_value',
+              'event_key' => 'event_value'
+            }
+          )
+          event.to_hash
+        end
+
+        it 'prioritizes event context over request context' do
+          expect(hash[:extra]['context_event_key']).to eq('event_value')
+          expect(hash[:extra]['context_key']).to eq('context_value')
+          expect(hash[:extra]['event_key']).to eq('event_value')
+        end
+      end
+    end
+  end
+end