roqua-support 0.1.24 → 0.1.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f1a04caaa757627735ff9ac6c83c220f21b0ea0
-  data.tar.gz: 9ff7c7a188bb759645ed74e7b1253b43f0eab896
+  metadata.gz: c59df394193f13d45c71f26b935f59e890b98f96
+  data.tar.gz: b0f6dc5880a4dfda1d96f554d5460dd180e6fc3b
 SHA512:
-  metadata.gz: e47f9a438f4cf20f34377b691e1d0964f5fcaec675f195297c109f689a12c63bf5b4445fdcaf801ad6213a199d1485493b71661a8e7868e275d3c0c4a2b2e54f
-  data.tar.gz: '09c7e888632d9dd19df77b2d3a2a5813d10063c1ea19ef81bec447e0e9055815539d7318e6a0f45b71f2bd510eb4d22a98bac385140796932390b9ce63d933fc'
+  metadata.gz: 0ccdada5a2cff7e753ae5e8d0278473a70d4e39b7c0f85f1287811946850f73612ade4bed1d5a081290cc6edde938a4190a32969cad62913e5e401e178a57f68
+  data.tar.gz: 29ea857840bd5f40b59efd2b94eb599909cec72d2e9b58dcd16e71a210935ca9dd6344ad2dee79fda8772257db4edfa2276e9cd57745618d35c143b823474935

data/.gitlab-ci.yml

@@ -1,21 +1,43 @@
-image: "roqua/roqua-build-images:ruby-2.3.3-phantomjs-2.1.1-bundler-gemnasium"
+image: "registry.roqua.nl/roqua/roqua-build-images:ruby-2.3-rails-base-test"
 
 variables:
   RAILS_ENV: "test"
-  
+
+stages:
+  - test
+  - publish
+
+cache:
+  paths:
+    - .gems
+
 before_script:
-  - bundle install
-  - gem install appraisal
+  - export BUNDLE_PATH=$CI_PROJECT_DIR/.gems
+  - bundle --jobs 2 --retry 3
   - bundle exec appraisal
+  - bundle --jobs 2 --retry 3
 
 rails_41:
+  stage: test
   script:
     - bundle exec appraisal rails41 bundle exec rspec
 
 rails_42:
+  stage: test
   script:
     - bundle exec appraisal rails42 bundle exec rspec
 
 rails_50:
+  stage: test
+  script:
+    - bundle exec appraisal rails50 bundle exec rspec
+
+build_and_publish_gem:
+  stage: publish
+  dependencies:
+    - rails_41
+    - rails_42
+    - rails_50
   script:
-    - bundle exec appraisal rails50 bundle exec rspec
+    - gem build roqua-support.gemspec
+    - gem push roqua-support-0.1.25.gem

data/Gemfile

@@ -9,6 +9,7 @@ gem 'roqua_styleguide', git: 'https://gitlab.roqua.nl/roqua/styleguide.git'
 group :test do
   gem 'actionpack', '>= 4.0'
   gem 'active_interaction', '~> 3.0'
+  gem 'appsignal'
   gem 'combustion', '~> 0.5.2'
   gem 'guard-rspec', '~> 4.2.6'
   gem 'responders'

data/Gemfile.lock

@@ -8,7 +8,7 @@ GIT
 PATH
   remote: .
   specs:
-    roqua-support (0.1.23)
+    roqua-support (0.1.25)
       active_interaction (~> 3.0)
       activesupport (>= 3.2, < 6)
       naught (~> 1.0)
@@ -42,6 +42,8 @@ GEM
       bundler
       rake
       thor (>= 0.14.0)
+    appsignal (2.3.1)
+      rack
     ast (2.3.0)
     builder (3.2.3)
     coderay (1.1.1)
@@ -162,10 +164,11 @@ DEPENDENCIES
   actionpack (>= 4.0)
   active_interaction (~> 3.0)
   appraisal
+  appsignal
   bundler (~> 1.0)
   combustion (~> 0.5.2)
   guard-rspec (~> 4.2.6)
-  rake
+  rake (~> 12.1)
   responders
   roqua-support!
   roqua_styleguide!

data/Guardfile

@@ -3,6 +3,6 @@
 
 guard :rspec, cmd: 'bundle exec rspec --colour' do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 end

data/lib/roqua/support/errors.rb

@@ -20,88 +20,71 @@ module Roqua
       end
 
       def self.report(exception, context = {})
-        return if const_defined?(:Rails) and Rails.env.test?
-        context = {} unless context.is_a? Hash
+        return if const_defined?(:Rails) && Rails.env.test?
 
-        parameters, controller, skip_backtrace = merge_parameters(exception, context)
+        namespace, parameters, _controller, skip_backtrace = merge_parameters(exception, context)
+        notification_urls = [notify_appsignal(exception, parameters, namespace)]
 
-        notification_urls = [notify_airbrake(exception, controller, parameters),
-                             notify_appsignal(exception, parameters)]
         # Notify Roqua logging
         log_exception(exception, parameters, notification_urls.compact, skip_backtrace)
       end
 
-      private
-
-      def self.merge_parameters(exception, context = {})
-        parameters = extra_parameters.dup
-        controller = context.delete :controller
-        skip_backtrace = context.delete :skip_backtrace
-        parameters.merge! context
-        parameters.merge! extra_parameters_from_exception(exception)
-        [parameters, controller, skip_backtrace]
-      rescue Exception
+      def self.appsignal_namespace_for_category(category)
+        case category
+        when :background then Appsignal::Transaction::BACKGROUND_JOB
+        when :web then        Appsignal::Transaction::HTTP_REQUEST
+        else                  Appsignal::Transaction::BLANK
+        end
       end
 
-      def self.extra_parameters_from_exception(exception)
-        exception.instance_variable_get(:@roqua_extra_parameters) || {}
-      end
+      class << self
+        private
 
-      def self.log_exception(exception, parameters = {}, notification_urls = [], skip_backtrace = false)
-        if Roqua.respond_to?(:logger)
-          exception_info = {class_name: exception.class.to_s,
-                            message: exception.message,
-                            parameters: parameters}
-          exception_info[:notification_urls] = notification_urls if notification_urls.present?
-          exception_info[:backtrace] = exception.backtrace unless skip_backtrace
-          puts exception_info.inspect
-          Roqua.logger.error('roqua.exception', exception_info)
+        def merge_parameters(exception, context = {})
+          controller = context.delete :controller
+          skip_backtrace = context.delete :skip_backtrace
+          namespace = context.delete(:namespace) || :background
+
+          [namespace,
+           extra_parameters.merge(context).merge(extra_parameters_from_exception(exception)),
+           controller,
+           skip_backtrace]
         end
-      rescue Exception
-      end
 
-      def self.notify_airbrake(exception, controller, parameters = {})
-        if const_defined?(:Airbrake)
-          if controller && controller.respond_to?(:airbrake_request_data)
-            request_data = controller.airbrake_request_data
-            if request_data.is_a?(Hash)
-              request_data[:parameters] ||= {}
-              if request_data[:parameters].is_a?(Hash)
-                request_data[:parameters] = parameters.merge request_data[:parameters]
-              end
-            else
-              request_data = nil
-            end
+        def extra_parameters_from_exception(exception)
+          exception.instance_variable_get(:@roqua_extra_parameters) || {}
+        end
+
+        def log_exception(exception, parameters = {}, notification_urls = [], skip_backtrace = false)
+          if Roqua.respond_to?(:logger)
+            exception_info = {class_name: exception.class.to_s,
+                              message: exception.message,
+                              parameters: parameters}
+            exception_info[:notification_urls] = notification_urls if notification_urls.present?
+            exception_info[:backtrace] = exception.backtrace unless skip_backtrace
+            puts exception_info.inspect
+            Roqua.logger.error('roqua.exception', exception_info)
           end
-          request_data ||= {parameters: parameters}
-          uuid = Airbrake.notify_or_ignore(exception, request_data)
-          "https://airbrake.io/locate/#{uuid}" if uuid
+        rescue Exception
         end
-      rescue Exception
-      end
 
-      def self.notify_appsignal(exception, parameters = {})
-        if const_defined?(:Appsignal) and
-           not Appsignal.is_ignored_exception?(exception)
-          # TODO: If and when https://github.com/appsignal/appsignal/pull/9 is merged,
-          # this functionality should be supported directly by Appsignal.send_exception.
-          # Appsignal.send_exception(exception, parameters: parameters)
+        def notify_appsignal?(exception)
+          const_defined?(:Appsignal) && !Appsignal.is_ignored_exception?(exception) && Appsignal.active?
+        end
+
+        def notify_appsignal(exception, labels, namespace)
+          return unless notify_appsignal?(exception)
+
+          namespace = appsignal_namespace_for_category(namespace)
+          current_transaction = Appsignal::Transaction.current
 
-          if Appsignal.active?
-            # Hackety hack around stateful mess of Appsignal gem
-            if Appsignal::Transaction.current
-              Appsignal::Transaction.current.set_tags(parameters)
-              Appsignal::Transaction.current.add_exception(exception)
-            else
-              transaction = Appsignal::Transaction.create(SecureRandom.uuid, ENV.to_hash)
-              transaction.set_tags(parameters)
-              transaction.add_exception(exception)
-              transaction.complete!
-              Appsignal.agent.send_queue
-            end
+          if current_transaction.namespace == Appsignal::Transaction::HTTP_REQUEST
+            current_transaction.set_tags(labels)
+            current_transaction.add_exception(exception)
+          else
+            Appsignal.send_error exception, labels, namespace
           end
         end
-      rescue Exception
       end
     end
   end

data/lib/roqua-support/version.rb

@@ -1,5 +1,5 @@
 module Roqua
   module Support
-    VERSION = '0.1.24'.freeze
+    VERSION = '0.1.25'.freeze
   end
 end

data/roqua-support.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'active_interaction', '~> 3.0'
 
   gem.add_development_dependency 'bundler', '~> 1.0'
-  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rake', '~> 12.1'
   gem.add_development_dependency 'rspec', '>= 2.12.0', '< 4.0'
+  gem.add_development_dependency 'appsignal', '~> 2.3', '>= 2.3.1'
 end

data/spec/roqua/support/errors_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'roqua/support/errors'
+require 'appsignal'
 
 describe 'Error reporting' do
   let(:exception) do
@@ -19,34 +20,34 @@ describe 'Error reporting' do
 
   context 'when the Roqua logger is defined' do
     it 'supports default extra params' do
-      Roqua::Support::Errors.stub(extra_parameters: {organization: 'some_org'})
-      Roqua.logger.should_receive(:error).with('roqua.exception',
-                                               class_name: 'Exception',
-                                               message: 'exception_message',
-                                               backtrace: ['back', 'trace', 'lines'],
-                                               parameters: {organization: 'some_org'})
+      allow(Roqua::Support::Errors).to receive(:extra_parameters).and_return(organization: 'some_org')
+      expect(Roqua.logger).to receive(:error).with('roqua.exception',
+                                                   class_name: 'Exception',
+                                                   message: 'exception_message',
+                                                   backtrace: ['back', 'trace', 'lines'],
+                                                   parameters: {organization: 'some_org'})
       Roqua::Support::Errors.report exception
     end
 
     it 'sends notifications to the eventlog' do
-      Roqua.logger.should_receive(:error).with('roqua.exception',
-                                               class_name: 'Exception',
-                                               message: 'exception_message',
-                                               backtrace: ['back', 'trace', 'lines'],
-                                               parameters: {})
+      expect(Roqua.logger).to receive(:error).with('roqua.exception',
+                                                   class_name: 'Exception',
+                                                   message: 'exception_message',
+                                                   backtrace: ['back', 'trace', 'lines'],
+                                                   parameters: {})
       Roqua::Support::Errors.report exception
     end
 
     it 'skips the backtrace when the skip_backtrace flag is set' do
-      Roqua.logger.should_receive(:error).with('roqua.exception',
-                                               class_name: 'Exception',
-                                               message: 'exception_message',
-                                               parameters: {})
+      expect(Roqua.logger).to receive(:error).with('roqua.exception',
+                                                   class_name: 'Exception',
+                                                   message: 'exception_message',
+                                                   parameters: {})
       Roqua::Support::Errors.report exception, skip_backtrace: true
     end
 
     it 'can add extra parameters by calling add_parameters' do
-      Roqua.logger.should_receive(:error).with \
+      expect(Roqua.logger).to receive(:error).with \
         'roqua.exception', class_name: 'RuntimeError',
                            message: 'exception_message',
                            parameters: {more: 'params',
@@ -69,7 +70,7 @@ describe 'Error reporting' do
     end
 
     it 'will not fail when called outside of rescue or when passed the wrong format to add_parameters' do
-      Roqua.logger.should_receive(:error).with \
+      expect(Roqua.logger).to receive(:error).with \
         'roqua.exception', class_name: 'RuntimeError',
                            message: 'exception_message',
                            parameters: {}
@@ -86,75 +87,77 @@ describe 'Error reporting' do
         Roqua::Support::Errors.report e, skip_backtrace: true
       end
     end
-
-    it 'logs notification_urls when present' do
-      stub_const('Airbrake', double('Airbrake', notify_or_ignore: 'uuid'))
-      Roqua.logger.should_receive(:error)
-                  .with('roqua.exception',
-                        class_name: 'Exception',
-                        message: 'exception_message',
-                        backtrace: ['back', 'trace', 'lines'],
-                        notification_urls: ['https://airbrake.io/locate/uuid'],
-                        parameters: {})
-      Roqua::Support::Errors.report exception
-    end
   end
 
-  context 'when Airbrake is defined' do
+  context 'when Appsignal is loaded' do
+    let(:agent)       { double("agent") }
+    let(:transaction) { double("transaction") }
+
     before do
-      stub_const('Airbrake', double('Airbrake', is_ignored_exception?: false))
+      allow(Appsignal).to receive(:active?).and_return(true)
+      allow(Appsignal).to receive(:is_ignored_exception?).and_return(false)
+      allow(Appsignal).to receive(:agent).and_return(agent)
     end
 
-    it 'sends notifications to airbrake' do
-      Airbrake.should_receive(:notify_or_ignore).with(exception, parameters: {})
+    it 'it will send an error' do
+      expect(Appsignal).to receive(:send_error)
       Roqua::Support::Errors.report exception
     end
 
-    it 'adds request data when a controller is passed in' do
-      controller = double(airbrake_request_data: {request: 'data', parameters: {request: 'param'}})
-      expect(Airbrake).to receive(:notify_or_ignore)
-                      .with(exception, request: 'data', parameters: {request: 'param', some: 'context'})
-      Roqua::Support::Errors.report exception, controller: controller, some: 'context'
+    it 'defaults to a background job' do
+      expect(Appsignal).to receive(:send_error).with(exception, {}, Appsignal::Transaction::BACKGROUND_JOB)
+      Roqua::Support::Errors.report exception
     end
 
-    it 'does not fail with context of incompatible type' do
-      expect(Airbrake).to receive(:notify_or_ignore).with(exception, parameters: {})
-      Roqua::Support::Errors.report exception, ['controller', 'extra_param']
-    end
+    it 'it will send an error under the provided category' do
+      expect(Appsignal)
+        .to receive(:send_error)
+        .with(exception, {a: 'b'}, Appsignal::Transaction::HTTP_REQUEST)
 
-    it 'does not fail with request data of incompatible type' do
-      controller = double(airbrake_request_data: ['request', 'data'])
-      expect(Airbrake).to receive(:notify_or_ignore).with(exception, parameters: {})
-      Roqua::Support::Errors.report exception, controller: controller
+      Roqua::Support::Errors.report exception, a: 'b', namespace: :web
     end
-  end
 
-  context 'when Appsignal is loaded' do
-    let(:agent)       { double("agent") }
-    let(:transaction) { double("transaction") }
+    describe 'when a current transaction is present' do
+      let(:current_transaction) do
+        Appsignal::Transaction.new(SecureRandom.uuid, Appsignal::Transaction::HTTP_REQUEST, nil)
+      end
 
-    it 'sends notifications to appsignal when there is no current exception' do
-      stub_const("Appsignal", Module.new)
-      Appsignal.stub(active?: true)
-      Appsignal.stub(is_ignored_exception?: false, agent: agent)
-      stub_const("Appsignal::Transaction", double("Transaction", create: transaction, current: nil))
+      before do
+        expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(current_transaction)
+      end
 
-      transaction.should_receive(:set_tags).with({})
-      transaction.should_receive(:add_exception).with(exception)
-      transaction.should_receive(:complete!)
-      agent.should_receive(:send_queue)
-      Roqua::Support::Errors.report exception
+      it 'sets the correct properties if a current transaction is present' do
+        expect(current_transaction).to receive(:set_tags).with(a: 'b').and_call_original
+        expect(current_transaction).to receive(:add_exception).with(exception).and_call_original
+
+        Roqua::Support::Errors.report exception, a: 'b', namespace: :web
+      end
+
+      describe "if the current transaction isn't a http request" do
+        let(:current_transaction) do
+          Appsignal::Transaction.new(SecureRandom.uuid, Appsignal::Transaction::BACKGROUND_JOB, nil)
+        end
+
+        it "will not set the properties if the current transaction isn't a http request" do
+          expect(current_transaction).to_not receive(:set_tags)
+          expect(current_transaction).to_not receive(:add_exception)
+
+          Roqua::Support::Errors.report exception, a: 'b', namespace: :web
+        end
+      end
     end
+  end
 
-    it 'sends notifications to appsignal when there already is a current exception' do
-      stub_const("Appsignal", Module.new)
-      Appsignal.stub(active?: true)
-      Appsignal.stub(is_ignored_exception?: false, agent: agent)
-      stub_const("Appsignal::Transaction", double("Transaction", current: transaction))
+  context '.appsignal_namespace_for_category' do
+    it 'returns the correct string based on the category' do
+      expect(Roqua::Support::Errors.appsignal_namespace_for_category(:background))
+        .to eql(Appsignal::Transaction::BACKGROUND_JOB)
 
-      transaction.should_receive(:set_tags).with({})
-      transaction.should_receive(:add_exception).with(exception)
-      Roqua::Support::Errors.report exception
+      expect(Roqua::Support::Errors.appsignal_namespace_for_category(:web))
+        .to eql(Appsignal::Transaction::HTTP_REQUEST)
+
+      expect(Roqua::Support::Errors.appsignal_namespace_for_category(''))
+        .to eql(Appsignal::Transaction::BLANK)
     end
   end
 end

data/spec/spec_helper.rb

@@ -5,4 +5,5 @@ require 'combustion'
 
 Combustion.initialize! :action_controller
 
+require 'appsignal'
 require 'rspec/rails'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roqua-support
 version: !ruby/object:Gem::Version
-  version: 0.1.24
+  version: 0.1.25
 platform: ruby
 authors:
 - Marten Veldthuis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-25 00:00:00.000000000 Z
+date: 2017-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -76,16 +76,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +106,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: appsignal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.1
 description: 'Logging backend, freedom patches, '
 email: marten@roqua.nl
 executables: []
@@ -190,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Helper objects and proxies used by a lot of RoQua applications