bugno-ruby 0.1.9

data/lib/bugno.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bugno/logger'
+require 'bugno/configuration'
+require 'bugno/event'
+
+if defined?(Rails)
+  require 'bugno/railtie'
+  require 'bugno/generator/bugno_generator'
+end
+
+module Bugno
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configured?
+      !!configuration.api_key
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/bugno/backtrace.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Bugno
+  class Backtrace
+    MAX_CONTEXT_LENGTH = 4
+
+    attr_reader :backtrace
+    attr_reader :files
+
+    def initialize(backtrace)
+      @backtrace = backtrace
+      @files = {}
+    end
+
+    def parse_backtrace
+      @backtrace.map do |line|
+        match = line.match(/(.*):(\d+)(?::in `([^']+)')?/)
+
+        return nil unless match
+
+        filename = match[1]
+        lineno = match[2].to_i
+        method = match[3]&.tr('0-9', '')
+        frame_data = {
+          code: nil,
+          lineno: lineno,
+          method: method,
+          context: nil,
+          filename: filename
+        }
+
+        frame_data.merge(extra_frame_data(filename, lineno))
+      end
+    end
+
+    def extra_frame_data(filename, lineno)
+      file_lines = get_file_lines(filename)
+
+      {
+        code: code_data(file_lines, lineno),
+        context: context_data(file_lines, lineno)
+      }
+    end
+
+    def get_file_lines(filename)
+      @files[filename] ||= read_file(filename)
+    end
+
+    def read_file(filename)
+      return unless File.exist?(filename)
+
+      File.read(filename).split("\n")
+    rescue StandardError
+      nil
+    end
+
+    def code_data(file_lines, lineno)
+      file_lines[lineno - 1]
+    end
+
+    def context_data(file_lines, lineno)
+      {
+        pre: pre_data(file_lines, lineno),
+        post: post_data(file_lines, lineno)
+      }
+    end
+
+    def post_data(file_lines, lineno)
+      from_line = lineno
+      number_of_lines = [from_line + MAX_CONTEXT_LENGTH, file_lines.size].min - from_line
+
+      file_lines[from_line, number_of_lines]
+    end
+
+    def pre_data(file_lines, lineno)
+      to_line = lineno - 2
+      from_line = [to_line - MAX_CONTEXT_LENGTH + 1, 0].max
+
+      file_lines[from_line, (to_line - from_line + 1)].select { |line| line && !line.empty? }
+    end
+  end
+end

data/lib/bugno/configuration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Bugno
+  API_URL = 'https://api.bugno.io'
+  IGNORE_DEFAULT = [
+    'AbstractController::ActionNotFound',
+    'ActionController::InvalidAuthenticityToken',
+    'ActionController::RoutingError',
+    'ActionController::UnknownAction',
+    'ActiveRecord::RecordNotFound',
+    'ActiveJob::DeserializationError'
+  ].freeze
+
+  class Configuration
+    attr_accessor :api_key
+    attr_accessor :environment
+    attr_accessor :framework
+    attr_accessor :api_url
+    attr_accessor :exclude_rails_exceptions
+    attr_accessor :excluded_exceptions
+    attr_accessor :scrub_fields
+    attr_accessor :scrub_headers
+    attr_accessor :scrub_user
+    attr_accessor :scrub_password
+    attr_accessor :scrub_whitelist
+    attr_accessor :current_user_method
+    attr_accessor :send_in_background
+    attr_accessor :usage_environments
+
+    def initialize
+      @api_key = nil
+      @environment = nil
+      @framework = 'ruby'
+      @api_url = API_URL
+      @excluded_exceptions = IGNORE_DEFAULT
+      @exclude_rails_exceptions = false
+      @scrub_fields = %i[passwd password password_confirmation secret
+                         confirm_password password_confirmation secret_token
+                         api_key access_token session_id]
+      @scrub_headers = ['Authorization']
+      @scrub_user = true
+      @scrub_password = true
+      @scrub_whitelist = []
+      @current_user_method = 'current_user'
+      @send_in_background = true
+      @usage_environments = %w[production]
+    end
+  end
+end

data/lib/bugno/encoding/encoder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Bugno
+  module Encoding
+    class Encoder
+      ALL_ENCODINGS = [::Encoding::UTF_8, ::Encoding::ISO_8859_1, ::Encoding::ASCII_8BIT, ::Encoding::US_ASCII].freeze
+      ASCII_ENCODINGS = [::Encoding::US_ASCII, ::Encoding::ASCII_8BIT, ::Encoding::ISO_8859_1].freeze
+      ENCODING_OPTIONS = { invalid: :replace, undef: :replace, replace: '' }.freeze
+      UTF8 = 'UTF-8'
+      BINARY = 'binary'
+
+      attr_accessor :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def encode
+        value = object.to_s
+        encoding = value.encoding
+
+        # This will be most of cases so avoid force anything for them
+        encoded_value = if encoding == ::Encoding::UTF_8 && value.valid_encoding?
+                          value
+                        else
+                          force_encoding(value).encode(*encoding_args(value))
+                        end
+
+        object.is_a?(Symbol) ? encoded_value.to_sym : encoded_value
+      end
+
+      private
+
+      def force_encoding(value)
+        return value if value.frozen?
+
+        value.force_encoding(detect_encoding(value)) if value.encoding == ::Encoding::UTF_8
+
+        value
+      end
+
+      def detect_encoding(v)
+        value = v.dup
+
+        ALL_ENCODINGS.detect do |encoding|
+          begin
+            # Seems #codepoints is faster than #valid_encoding?
+            value.force_encoding(encoding).encode(::Encoding::UTF_8).codepoints
+            true
+          rescue StandardError
+            false
+          end
+        end
+      end
+
+      def encoding_args(value)
+        args = [UTF8]
+        args << BINARY if ASCII_ENCODINGS.include?(value.encoding)
+        args << ENCODING_OPTIONS
+
+        args
+      end
+    end
+  end
+end

data/lib/bugno/encoding/encoding.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bugno
+  module Encoding
+    class << self
+      attr_accessor :encoding_class
+    end
+
+    def self.setup
+      if String.instance_methods.include?(:encode)
+        require 'bugno/encoding/encoder'
+        self.encoding_class = Bugno::Encoding::Encoder
+      else
+        require 'bugno/encoding/legacy_encoder'
+        self.encoding_class = Bugno::Encoding::LegacyEncoder
+      end
+    end
+
+    def self.encode(object)
+      can_be_encoded = object.is_a?(String) || object.is_a?(Symbol)
+
+      return object unless can_be_encoded
+
+      encoding_class.new(object).encode
+    end
+  end
+end
+
+Bugno::Encoding.setup

data/lib/bugno/encoding/legacy_encoder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'iconv'
+
+module Buhhub
+  module Encoding
+    class LegacyEncoder
+      attr_accessor :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def encode
+        value = object.to_s
+        encoded_value = ::Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
+
+        object.is_a?(Symbol) ? encoded_value.to_sym : encoded_value
+      end
+    end
+  end
+end

data/lib/bugno/event.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'bugno/request_data_extractor'
+require 'bugno/backtrace'
+require 'bugno/encoding/encoding'
+require 'rails' if defined?(Rails)
+
+module Bugno
+  class Event
+    include RequestDataExtractor
+    attr_reader :data
+
+    def initialize(options = {})
+      @env = options[:env]
+      @job = options[:job]
+      @exception = options[:exception]
+      build_data
+    end
+
+    private
+
+    def build_data
+      @data = {
+        title: truncate(@exception.class.inspect),
+        message: truncate(@exception.message),
+        server_data: server_data,
+        created_at: Time.now.to_i,
+        framework: Bugno.configuration.framework,
+        environment: Bugno.configuration.environment
+      }
+      merge_extra_data
+    end
+
+    def merge_extra_data
+      @data.merge!(backtrace: Backtrace.new(@exception.backtrace).parse_backtrace) if @exception.backtrace
+      @data.merge!(extract_request_data_from_rack(@env)) if @env
+      @data.merge!(background_data: @job) if @job
+    end
+
+    # TODO: move to utility module
+    def truncate(string)
+      string.is_a?(String) ? string[0...3000] : ''
+    end
+
+    # TODO: refactor
+    def server_data
+      data = { host: Socket.gethostname }
+      data[:root] = Rails.root.to_s if defined?(Rails)
+      data
+    end
+  end
+end

data/lib/bugno/filter/params.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module Bugno
+  module Filter
+    class Params
+      SKIPPED_CLASSES = [::Tempfile].freeze
+      ATTACHMENT_CLASSES = %w[ActionDispatch::Http::UploadedFile Rack::Multipart::UploadedFile].freeze
+      SCRUB_ALL = :scrub_all
+
+      def self.call(*args)
+        new.call(*args)
+      end
+
+      def self.scrub_value
+        '[FILTERED]'
+      end
+
+      def call(options = {})
+        params = options[:params]
+        return {} unless params
+
+        @scrubbed_object_ids = {}
+
+        config = options[:config]
+        extra_fields = options[:extra_fields]
+        whitelist = options[:whitelist] || []
+
+        scrub(params, build_scrub_options(config, extra_fields, whitelist))
+      end
+
+      private
+
+      def build_scrub_options(config, extra_fields, whitelist)
+        ary_config = Array(config)
+
+        {
+          fields_regex: build_fields_regex(ary_config, extra_fields),
+          scrub_all: ary_config.include?(SCRUB_ALL),
+          whitelist: build_whitelist_regex(whitelist)
+        }
+      end
+
+      def build_fields_regex(config, extra_fields)
+        fields = config.find_all { |f| f.is_a?(String) || f.is_a?(Symbol) }
+        fields += Array(extra_fields)
+
+        return unless fields.any?
+
+        Regexp.new(fields.map { |val| Regexp.escape(val.to_s).to_s }.join('|'), true)
+      end
+
+      def build_whitelist_regex(whitelist)
+        fields = whitelist.find_all { |f| f.is_a?(String) || f.is_a?(Symbol) }
+        return unless fields.any?
+
+        Regexp.new(fields.map { |val| /\A#{Regexp.escape(val.to_s)}\z/ }.join('|'))
+      end
+
+      def scrub(params, options)
+        return params if @scrubbed_object_ids[params.object_id]
+
+        @scrubbed_object_ids[params.object_id] = true
+
+        fields_regex = options[:fields_regex]
+        scrub_all = options[:scrub_all]
+        whitelist_regex = options[:whitelist]
+
+        return scrub_array(params, options) if params.is_a?(Array)
+
+        params.to_hash.each_with_object({}) do |(key, value), result|
+          encoded_key = Bugno::Encoding.encode(key).to_s
+          result[key] = if (fields_regex === encoded_key) && !(whitelist_regex === encoded_key)
+                          scrub_value
+                        elsif value.is_a?(Hash)
+                          scrub(value, options)
+                        elsif scrub_all && !(whitelist_regex === encoded_key)
+                          scrub_value
+                        elsif value.is_a?(Array)
+                          scrub_array(value, options)
+                        elsif skip_value?(value)
+                          "Skipped value of class '#{value.class.name}'"
+                        else
+                          bugno_filtered_param_value(value)
+                        end
+        end
+      end
+
+      def scrub_array(array, options)
+        array.map do |value|
+          value.is_a?(Hash) ? scrub(value, options) : bugno_filtered_param_value(value)
+        end
+      end
+
+      def scrub_value
+        '[FILTERED]'
+      end
+
+      def bugno_filtered_param_value(value)
+        if ATTACHMENT_CLASSES.include?(value.class.name)
+          begin
+            attachment_value(value)
+          rescue StandardError
+            'Uploaded file'
+          end
+        else
+          value
+        end
+      end
+
+      def skip_value?(value)
+        SKIPPED_CLASSES.any? { |klass| value.is_a?(klass) }
+      end
+    end
+  end
+end