sentry-raven 3.1.1 → 3.1.2

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

@@ -1,19 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

data/sentry-ruby/sentry-ruby.gemspec

@@ -1,26 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,443 +0,0 @@
-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