bugno-ruby 0.1.9

data/lib/bugno/generator/bugno_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+class BugnoGenerator < Rails::Generators::Base
+  source_root File.expand_path(__dir__)
+
+  argument :api_key, required: false
+
+  def generate_layout
+    template 'bugno_initializer.rb.erb', 'config/initializers/bugno.rb'
+  end
+end

data/lib/bugno/generator/bugno_initializer.rb.erb

@@ -0,0 +1,36 @@
+Bugno.configure do |config|
+<% if api_key -%>
+  # Specify api key to send exception to Bugno
+  config.api_key = '<%= api_key %>'
+<% else -%>
+  # Specify api key to send exception to Bugno
+  config.api_key = 'MISSING_API_KEY'
+<% end -%>
+
+  # Send in background with threading:
+  config.send_in_background = true
+
+  # Skip rails related exceptions:
+  config.exclude_rails_exceptions = false
+
+  # Specify which rails exception to skip:
+  config.excluded_exceptions = [
+   'AbstractController::ActionNotFound',
+   'ActionController::InvalidAuthenticityToken',
+   'ActionController::RoutingError',
+   'ActionController::UnknownAction',
+   'ActiveRecord::RecordNotFound',
+   'ActiveJob::DeserializationError'
+  ]
+
+  # Specify or add usage environments:
+  config.usage_environments = %w[production]
+  # config.usage_environments << 'development'
+
+  # Specify current user method:
+  config.current_user_method = 'current_user'
+
+  # Add scrub fields and headers:
+  # config.scrub_fields << 'password'
+  # config.scrub_headers << 'access_token'
+end

data/lib/bugno/handler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bugno/event'
+require 'bugno/reporter'
+
+module Bugno
+  class Handler
+    attr_reader :event, :reporter, :exception, :env, :job
+
+    def initialize(options = {})
+      @exception = options[:exception]
+      @event = Event.new(exception: options[:exception], env: options[:env], job: options[:job])
+      @reporter = Reporter.new
+    end
+
+    def self.call(options = {})
+      self.new(options).handle_exception
+    end
+
+    def handle_exception
+      return if excluded_exception? || !usage_environment?
+
+      @reporter.request.body = @event.data.to_json
+      Bugno.configuration.send_in_background ? Thread.new { @reporter.send } : @reporter.send
+    end
+
+    private
+
+    def excluded_exception?
+      Bugno.configuration.exclude_rails_exceptions && \
+        Bugno.configuration.excluded_exceptions.include?(@exception.class.inspect)
+    end
+
+    def usage_environment?
+      Bugno.configuration.usage_environments.include?(Bugno.configuration.environment)
+    end
+  end
+end

data/lib/bugno/logger.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bugno
+  class << self
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    %w[debug info warn error].each do |level|
+      define_method(:"log_#{level}") do |message|
+        message = "[Bugno] #{message}"
+        logger.send(level, message)
+      end
+    end
+  end
+end

data/lib/bugno/middleware/rails/active_job_extensions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'bugno/handler'
+
+module Bugno
+  module Middleware
+    module Rails
+      module ActiveJobExtensions
+        ADAPTERS = %w[ActiveJob::QueueAdapters::SidekiqAdapter ActiveJob::QueueAdapters::DelayedJobAdapter].freeze
+
+        def self.included(base)
+          base.class_eval do
+            around_perform { |job, block| capture_and_reraise(job, block) }
+          end
+        end
+
+        def capture_and_reraise(job, block)
+          block.call
+        rescue Error
+          raise
+        rescue Exception => e
+          Handler.call(exception: e, job: job_data(job)) if Bugno.configured?
+          raise e
+        end
+
+        def job_data(job)
+          data = {
+            active_job: job.class.name,
+            arguments: job.arguments,
+            scheduled_at: job.scheduled_at,
+            job_id: job.job_id,
+            locale: job.locale
+          }
+          data[:provider_job_id] = job.provider_job_id if job.respond_to?(:provider_job_id)
+          data
+        end
+      end
+    end
+  end
+end
+
+class ActiveJob::Base
+  include Bugno::Middleware::Rails::ActiveJobExtensions
+end

data/lib/bugno/middleware/rails/bugno.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bugno/handler'
+
+module Bugno
+  module Middleware
+    module Rails
+      class BugnoMiddleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        rescue Error
+          raise
+        rescue Exception => e
+          Handler.call(exception: e, env: env) if Bugno.configured?
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/bugno/middleware/rails/show_exceptions.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bugno/handler'
+
+module Bugno
+  module Middleware
+    module ShowExceptions
+      def render_exception_with_bugno(env, exception)
+        if exception.is_a?(ActionController::RoutingError)
+          Handler.call(exception: exception, env: extract_scope_from(env)) if Bugno.configured?
+        end
+
+        render_exception_without_bugno(env, exception)
+      end
+
+      def call_with_bugno(env)
+        call_without_bugno(env)
+      rescue ActionController::RoutingError => e
+        raise e
+      end
+
+      def extract_scope_from(env)
+        env.env
+      end
+
+      def self.included(base)
+        base.send(:alias_method, :call_without_bugno, :call)
+        base.send(:alias_method, :call, :call_with_bugno)
+
+        base.send(:alias_method, :render_exception_without_bugno, :render_exception)
+        base.send(:alias_method, :render_exception, :render_exception_with_bugno)
+      end
+    end
+  end
+end

data/lib/bugno/railtie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Bugno
+  class Railtie < ::Rails::Railtie
+    initializer 'bugno.middleware.rails' do |app|
+      require 'bugno/middleware/rails/bugno'
+      require 'bugno/middleware/rails/show_exceptions'
+      require 'bugno/middleware/rails/active_job_extensions'
+      app.config.middleware.insert_after ActionDispatch::DebugExceptions,
+                                         Bugno::Middleware::Rails::BugnoMiddleware
+      ActionDispatch::DebugExceptions.send(:include, Bugno::Middleware::ShowExceptions)
+    end
+
+    initializer 'bugno.configuration' do
+      config.after_initialize do
+        Bugno.configure do |config|
+          config.environment = ENV['RACK_ENV'] || ::Rails.env
+          config.framework = 'rails'
+        end
+      end
+    end
+  end
+end

data/lib/bugno/reporter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Bugno
+  class Reporter
+    attr_reader :uri, :http
+    attr_accessor :request
+
+    def initialize
+      @uri = URI.parse("#{Bugno.configuration.api_url}/api/v1/projects/#{Bugno.configuration.api_key}/events")
+      @http = Net::HTTP.new(uri.host, uri.port)
+      @request = Net::HTTP::Post.new(uri.request_uri, 'Content-Type': 'application/json')
+    end
+
+    def send
+      http.use_ssl = true if uri.scheme == 'https'
+
+      response = http.request(request)
+      Bugno.log_info(api_response(response))
+    rescue StandardError => e
+      Bugno.log_error(e.message)
+    end
+
+    def api_response(response)
+      body = JSON.parse(response.body.presence || '{}')
+      message = body['message'] || body['error'] || response.message
+      "#{message.capitalize} | Code: #{response.code}"
+    end
+  end
+end

data/lib/bugno/request_data_extractor.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'bugno/filter/params'
+require 'bugno/encoding/encoder'
+
+module Bugno
+  module RequestDataExtractor
+    ALLOWED_HEADERS_REGEX = /^HTTP_|^CONTENT_TYPE$|^CONTENT_LENGTH$/.freeze
+    ALLOWED_BODY_PARSEABLE_METHODS = %w[POST PUT PATCH DELETE].freeze
+
+    def extract_request_data_from_rack(env)
+      rack_req = ::Rack::Request.new(env)
+      sensitive_params = sensitive_params_list(env)
+
+      post_params = scrub_params(post_params(rack_req), sensitive_params)
+      get_params = scrub_params(get_params(rack_req), sensitive_params)
+      route_params = scrub_params(route_params(env), sensitive_params)
+      session = scrub_params(request_session(env), sensitive_params)
+      cookies = scrub_params(request_cookies(rack_req), sensitive_params)
+      person_data = scrub_params(person_data(env), sensitive_params)
+
+      data = {
+        url: request_url(env),
+        ip_address: ip_address(env),
+        headers: headers(env),
+        http_method: request_method(env),
+        params: get_params,
+        route_params: route_params,
+        session: session,
+        cookies: cookies,
+        person_data: person_data
+      }
+      data[:params] = post_params if data[:params].empty?
+
+      data
+    end
+
+    def scrub_params(params, sensitive_params)
+      options = {
+        params: params,
+        config: Bugno.configuration.scrub_fields,
+        extra_fields: sensitive_params,
+        whitelist: Bugno.configuration.scrub_whitelist
+      }
+      Bugno::Filter::Params.call(options)
+    end
+
+    def person_data(env)
+      current_user = Bugno.configuration.current_user_method
+      controller = env['action_controller.instance']
+      person_data = begin
+                      controller.send(current_user).attributes
+                    rescue StandardError
+                      {}
+                    end
+      person_data
+    end
+
+    def sensitive_params_list(env)
+      Array(env['action_dispatch.parameter_filter'])
+    end
+
+    def request_session(env)
+      session = env.fetch('rack.session', {})
+
+      session.to_hash
+    rescue StandardError
+      {}
+    end
+
+    def request_cookies(rack_req)
+      rack_req.cookies
+    rescue StandardError
+      {}
+    end
+
+    def headers(env)
+      env.keys.grep(ALLOWED_HEADERS_REGEX).map do |header|
+        name = header.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+        if name == 'Cookie'
+          {}
+        elsif sensitive_headers_list.include?(name)
+          { name => Bugno::Filter::Params.scrub_value }
+        else
+          { name => env[header] }
+        end
+      end.inject(:merge)
+    end
+
+    def request_method(env)
+      env['REQUEST_METHOD'] || env[:method]
+    end
+
+    def request_url(env)
+      forwarded_proto = env['HTTP_X_FORWARDED_PROTO'] || env['rack.url_scheme'] || ''
+      scheme = forwarded_proto.split(',').first
+
+      host = env['HTTP_X_FORWARDED_HOST'] || env['HTTP_HOST'] || env['SERVER_NAME'] || ''
+      host = host.split(',').first.strip unless host.empty?
+
+      path = env['ORIGINAL_FULLPATH'] || env['REQUEST_URI']
+      unless path.nil? || path.empty?
+        path = '/' + path.to_s if path.to_s.slice(0, 1) != '/'
+      end
+
+      port = env['HTTP_X_FORWARDED_PORT']
+      if port && !(!scheme.nil? && scheme.casecmp('http').zero? && port.to_i == 80) && \
+         !(!scheme.nil? && scheme.casecmp('https').zero? && port.to_i == 443) && \
+         !(host.include? ':')
+        host = host + ':' + port
+      end
+
+      [scheme, '://', host, path].join
+    end
+
+    def ip_address(env)
+      ip_address_string = (env['action_dispatch.remote_ip'] || env['HTTP_X_REAL_IP'] || env['REMOTE_ADDR']).to_s
+    end
+
+    def get_params(rack_req)
+      rack_req.GET
+    rescue StandardError
+      {}
+    end
+
+    def post_params(rack_req)
+      rack_req.POST
+    rescue StandardError
+      {}
+    end
+
+    def route_params(env)
+      return {} unless defined?(Rails)
+
+      begin
+        environment = { method: request_method(env) }
+
+        ::Rails.application.routes.recognize_path(env['PATH_INFO'],
+                                                  environment)
+      rescue StandardError
+        {}
+      end
+    end
+
+    def sensitive_headers_list
+      Bugno.configuration.scrub_headers || []
+    end
+  end
+end

data/lib/bugno/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bugno
+  VERSION = '0.1.9'
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: bugno-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.9
+platform: ruby
+authors:
+- Dmitry Syvoglaz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- grayeyed16@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bugno.gemspec
+- lib/bugno.rb
+- lib/bugno/backtrace.rb
+- lib/bugno/configuration.rb
+- lib/bugno/encoding/encoder.rb
+- lib/bugno/encoding/encoding.rb
+- lib/bugno/encoding/legacy_encoder.rb
+- lib/bugno/event.rb
+- lib/bugno/filter/params.rb
+- lib/bugno/generator/bugno_generator.rb
+- lib/bugno/generator/bugno_initializer.rb.erb
+- lib/bugno/handler.rb
+- lib/bugno/logger.rb
+- lib/bugno/middleware/rails/active_job_extensions.rb
+- lib/bugno/middleware/rails/bugno.rb
+- lib/bugno/middleware/rails/show_exceptions.rb
+- lib/bugno/railtie.rb
+- lib/bugno/reporter.rb
+- lib/bugno/request_data_extractor.rb
+- lib/bugno/version.rb
+homepage: https://bugno.io/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Track your rails exceptions
+test_files: []