errordeck 0.1.0

data/lib/errordeck/errordeck/issue/stacktrace.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Errordeck
+  class Stacktrace
+    attr_accessor :abs_path, :function, :in_app, :filename, :lineno, :module, :vars, :context_line, :pre_context,
+                  :post_context
+
+    def initialize(project_root, line)
+      @abs_path = line.file
+      @function = line.method
+      @in_app = line.file.start_with?(project_root)
+      @filename = File.basename(line.file)
+      @lineno = line.line
+      @module = line.module_name
+      @vars = {}
+      set_contexts(line.file, line.line)
+    end
+
+    def as_json(*_options)
+      {
+        abs_path: @abs_path,
+        function: @function,
+        in_app: @in_app,
+        filename: @filename,
+        lineno: @lineno,
+        module: @module,
+        vars: @vars,
+        context_line: @context_line,
+        pre_context: @pre_context,
+        post_context: @post_context
+      }
+    end
+
+    def to_json(*options)
+      JSON.generate(as_json, *options)
+    end
+
+    def self.parse_from_backtrace(backtrace, project_root = nil)
+      project_root ||= File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+      error_backtrace = Errordeck::Backtrace.parse(backtrace)
+      return nil if error_backtrace.nil?
+
+      error_backtrace.lines.map { |line| new(project_root, line) }
+    end
+
+    private
+
+    def set_contexts(file, line_number)
+      return unless File.exist?(file)
+
+      source = File.readlines(file)
+      return if source.empty?
+
+      range_start = [line_number - 5, 0].max
+      range_end = [line_number + 3, source.length - 1].min
+
+      @pre_context = source[range_start...line_number - 1]
+      @context_line = source[line_number - 1]
+      @post_context = source[line_number...range_end + 1]
+    end
+  end
+end

data/lib/errordeck/middleware/rack.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# rack middleware to capture request context and exception to send to errordeck
+# Compare this snippet from lib/errordeck/middleware/rack.rb:
+
+module Errordeck
+  module Middleware
+    module Rack
+      def self.new(app)
+        ->(env) { call(env, app) }
+      end
+
+      def self.call(env, app)
+        Errordeck.wrap do |b|
+          b.set_request(env)
+          b.set_transaction(env["PATH_INFO"])
+
+          begin
+            app.call(env)
+          rescue Exception => e
+            b.capture(e)
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/errordeck/middleware/rails.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Errordeck
+  module Middleware
+    module Rails
+      class ErrordeckMiddleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          dup.call!(env)
+        end
+
+        def call!(env)
+          response = @app.call(env)
+        rescue Exception => e
+          notify_exception(env, e)
+          raise e
+        else
+          exception = collect_exception(env)
+          notify_exception(env, exception) if exception
+          response
+        end
+
+        private
+
+        def notify_exception(env, exception)
+          return unless exception
+
+          Errordeck.wrap do |b|
+            b.set_action_context(env)
+            b.capture(exception)
+          end
+        end
+
+        def collect_exception(env)
+          return nil unless env
+
+          env["action_dispatch.exception"] || env["sinatra.error"] || env["rack.exception"]
+        end
+      end
+    end
+  end
+
+  class Railtie < Rails::Railtie
+    initializer "errordeck.middleware.rails" do |app|
+      app.config.middleware.insert 0, Errordeck::Middleware::Rails::ErrordeckMiddleware
+    end
+  end
+end

data/lib/errordeck/plugin_require.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# check if rack is defined and require middleware
+if defined?(Rack)
+  require_relative "middleware/rack"
+  if defined?(Rack::Builder)
+    # Rack 2.0
+    Rack::Builder.include Errordeck::Middleware::Rack
+  end
+end
+# check if rails is defined and require middleware
+if defined?(Rails) && Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new("3.2") && defined?(Rails::Railtie)
+  require_relative "middleware/rails"
+end

data/lib/errordeck/request_handler.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Errordeck
+  class RequestHandler
+    attr_accessor :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def self.set_request_from_env(rack_env)
+      if defined?(Sinatra)
+        Sinatra::Request.new(rack_env)
+      elsif defined?(Rack)
+        Rack::Request.new(rack_env)
+      else
+        request_hash(rack_env)
+      end
+    end
+
+    def self.request_hash(rack_env)
+      request = {}
+      rack_env = rack_env.dup.transform_keys { |k| k.to_s.upcase }
+
+      if rack_env["REQUEST_URI"] || rack_env["URL"]
+        url = URI.parse(rack_env["REQUEST_URI"] || rack_env["URL"])
+        url.scheme ||= rack_env["RACK.URL_SCHEME"] || "https"
+        url.host ||= rack_env["HTTP_HOST"] || "localhost"
+      else
+        scheme = rack_env["RACK.URL_SCHEME"] || "https"
+        host = rack_env["HTTP_HOST"] || "localhost"
+        path = rack_env["PATH_INFO"] || "/"
+        query_string = rack_env["QUERY_STRING"] || ""
+        url = URI.parse("#{scheme}://#{host}#{path}")
+        url.query = query_string unless query_string.empty?
+      end
+
+      request[:url] = url.to_s
+      request[:query_string] = url.query || ""
+      request[:params] = rack_env["PARAMS"] || parse_query_string(request[:query_string])
+      request[:method] = rack_env["REQUEST_METHOD"] || "GET"
+      request[:cookies] =
+        rack_env["HTTP_COOKIE"] || rack_env["COOKIES"] ? parse_query_string(rack_env["HTTP_COOKIE"] || rack_env["COOKIES"]) : {}
+      request[:headers] = (rack_env["HEADERS"] || rack_env).select { |k, _| k.start_with?("HTTP_") }
+      request
+    end
+
+    def self.parse_from_rack_env(rack_env)
+      request = set_request_from_env(rack_env.dup)
+      new(request)
+    end
+
+    def method
+      if @request.respond_to?(:request_method)
+        @request.request_method
+      else
+        @request[:method]
+      end
+    end
+
+    def url
+      if @request.respond_to?(:url)
+        @request.url
+      else
+        @request[:url]
+      end
+    end
+
+    def params
+      if @request.respond_to?(:params)
+        (request.env["action_dispatch.request.parameters"] || request.params).to_hash || {}
+      else
+        @request[:params] || {}
+      end
+    end
+
+    def controller
+      params["controller"]
+    end
+
+    def action
+      params["action"]
+    end
+
+    def query_string
+      @request[:query_string] || @request.query_string
+    end
+
+    def cookies
+      @request[:cookies] || @request.cookies || {}
+    end
+
+    def headers
+      @request[:headers] || @request.env || {}
+    end
+
+    def to_hash
+      {
+        method: method,
+        url: url,
+        query_string: query_string,
+        cookies: cookies,
+        headers: headers,
+        params: params
+      }
+    end
+
+    def self.parse_query_string(query_string)
+      return query_string if query_string.is_a?(Hash)
+
+      query_string.split("&").each_with_object({}) do |pair, hash|
+        key, value = pair.split("=").map { |part| CGI.unescape(part) }
+        if hash.key?(key)
+          hash[key] = Array(hash[key])
+          hash[key] << value
+        else
+          hash[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/errordeck/scrubber/base.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Errordeck
+  module Scrubber
+    SENSITIVE_PARAMS = %w[password password_confirmation email secret token session].freeze
+    SENSITIVE_HEADERS = %w[Authorization Cookie Set-Cookie].freeze
+    SENSITIVE_VALUE = "[FILTERED]"
+  end
+end

data/lib/errordeck/scrubber/cookie.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Errordeck
+  module Scrubber
+    class Cookie
+      # scrub a cookie
+      def initialize(cookie)
+        @cookie = cookie
+      end
+
+      # scrub a cookie
+      def scrub
+        scrub_cookie(@cookie)
+      end
+
+      private
+
+      def scrub_cookie(cookie)
+        return nil if cookie.nil?
+
+        cookie.each do |key, _value|
+          cookie[key] = Errordeck::Scrubber::SENSITIVE_VALUE if Errordeck::Scrubber::SENSITIVE_PARAMS.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/errordeck/scrubber/header.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Errordeck
+  module Scrubber
+    class Header
+      # scrub an HTTP header
+      def initialize(header)
+        @header = header
+      end
+
+      # scrub an HTTP header
+      def scrub
+        scrub_header(@header)
+      end
+
+      private
+
+      def scrub_header(header)
+        return nil if header.nil?
+
+        header.to_h do |key, value|
+          if Errordeck::Scrubber::SENSITIVE_HEADERS.include?(key)
+            [key, Errordeck::Scrubber::SENSITIVE_VALUE]
+          else
+            [key, value]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/errordeck/scrubber/query_param.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Errordeck
+  module Scrubber
+    class QueryParam
+      # scrub a query parameter
+      def initialize(query, filter = nil)
+        @query = query
+        @filter = filter || Errordeck::Scrubber::SENSITIVE_PARAMS
+      end
+
+      # scrub a query parameter
+      def scrub
+        scrub_query(@query)
+      end
+
+      private
+
+      def scrub_query(query)
+        return nil if query.nil?
+
+        query.split("&").map do |param|
+          key, value = param.split("=")
+          if @filter.include?(key)
+            "#{key}=#{Errordeck::Scrubber::SENSITIVE_VALUE}"
+          else
+            param
+          end
+        end.join("&")
+      end
+    end
+  end
+end

data/lib/errordeck/scrubber/scrubber.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# require all in this file's directory
+require_relative "base"
+require_relative "url"
+require_relative "query_param"
+require_relative "header"
+require_relative "cookie"

data/lib/errordeck/scrubber/url.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Errordeck
+  module Scrubber
+    class Url
+      def initialize(url, filter = nil)
+        @url = url
+        @filter = filter || Errordeck::Scrubber::SENSITIVE_PARAMS
+      end
+
+      # remove sensitive data from url
+      def scrub
+        uri = URI.parse(@url)
+        uri.query = Errordeck::Scrubber::QueryParam.new(uri.query, @filter).scrub
+        uri.to_s
+      end
+    end
+  end
+end

data/lib/errordeck/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Errordeck
+  VERSION = "0.1.0"
+end

data/lib/errordeck/wrapper.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Errordeck
+  class Wrapper
+    attr_accessor :context
+    attr_reader :error_event, :transaction, :request, :user, :tags, :modules
+
+    def initialize
+      @error_event = nil
+      @transaction = nil
+      @request = nil
+      @user = nil
+      @tags = nil
+      @message = false
+      @already_sent = false
+      if Gem::Specification.respond_to?(:map)
+        @modules = Gem::Specification.to_h do |spec|
+          [spec.name, spec.version.to_s]
+        end
+      end
+      @context = Context.context
+    end
+
+    def send_event
+      return if @error_event.nil? && @message == true
+      return if @already_sent
+
+      uri = URI.parse("https://app.errordeck.com/api/#{config.project_id}/store")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request = Net::HTTP::Post.new(uri.request_uri, "Authorization" => "Bearer #{config.token}")
+      request["Content-Type"] = "application/json"
+      event_json = @error_event&.to_json
+      response = http.request(request, event_json)
+      @already_sent = true
+    rescue StandardError => e
+      raise Error, "Error sending issue to Errordeck: #{e.message}"
+    end
+
+    def capture(exception, user = nil, tags = nil)
+      @message = false
+      @error_event = generate_from_exception(exception)
+      @error_event.user = user || @user
+      @error_event.tags = tags || @tags
+      @error_event.request = @request
+      @error_event
+    end
+
+    def message(level, message, extra = nil)
+      @message = true
+      @error_event = generate_boxing_event(level, message, extra)
+      @error_event.user = @user
+      @error_event.tags = @tags
+      @error_event.request = @request
+      @error_event
+    end
+
+    def set_action_context(env)
+      request_handler = RequestHandler.parse_from_rack_env(env)
+      @request = Request.parse_from_request_handler(request_handler)
+    end
+
+    def set_transaction(transaction = nil)
+      @transaction = transaction
+    end
+
+    def set_request(env = nil)
+      @request = Request.parse_from_rack_env(env)
+    end
+
+    def user_context=(user)
+      @user = user
+    end
+
+    def tags_context=(tags)
+      @tags = tags
+    end
+
+    private
+
+    def generate_from_exception(exception)
+      exceptions = Errordeck::Exception.parse_from_exception(exception, project_root)
+      Event.new(
+        level: config.level || exception_severity(exception),
+        transaction: transaction,
+        server_name: server_name_env,
+        release: config.release,
+        dist: config.dist,
+        environment: config.environment || find_environment,
+        message: exception.message,
+        modules: modules,
+        exceptions: exceptions,
+        contexts: context
+      )
+    end
+
+    def project_root
+      return Rails.root.to_s if defined?(Rails)
+      return Sinatra::Application.root.to_s if defined?(Sinatra)
+      return Rack::Directory.new("").root.to_s if defined?(Rack)
+      return Bundler.root.to_s if defined?(Bundler)
+
+      File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+    end
+
+    def generate_boxing_event(level, message, extra = nil)
+      Event.new(
+        level: level,
+        transaction: transaction,
+        server_name: server_name_env,
+        release: config.release,
+        dist: config.dist,
+        environment: config.environment,
+        message: message,
+        modules: modules,
+        extra: extra,
+        contexts: context
+      )
+    end
+
+    def find_environment
+      # check if rails env is set or sinatra env is set
+      if defined?(Rails)
+        Rails.env
+      elsif defined?(Sinatra)
+        Sinatra::Base.environment
+      else
+        "production"
+      end
+    end
+
+    def exception_severity(exception)
+      case exception.class.to_s
+      when "SystemExit", "SignalException", "Interrupt", "NoMemoryError", "SecurityError"
+        :critical
+      when "RuntimeError", "TypeError", "LoadError", "NameError", "ArgumentError", "IndexError", "KeyError", "RangeError",
+           "NoMethodError", "FrozenError", "SocketError", "EncodingError", "Encoding::InvalidByteSequenceError",
+           "Encoding::UndefinedConversionError", "ZeroDivisionError", "SystemCallError", "Errno::EACCES",
+           "Errno::EADDRINUSE", "Errno::ECONNREFUSED", "Errno::ECONNRESET", "Errno::EEXIST", "Errno::EHOSTUNREACH",
+           "Errno::EINTR", "Errno::EINVAL", "Errno::EISDIR", "Errno::ENETDOWN", "Errno::ENETUNREACH", "Errno::ENOENT",
+           "Errno::ENOMEM", "Errno::ENOSPC", "Errno::ENOTCONN", "Errno::ENOTDIR", "Errno::EPIPE", "Errno::ERANGE",
+           "Errno::ETIMEDOUT", "Errno::ENOTEMPTY"
+        :error
+      when "Warning", "SecurityWarning", "DeprecatedError", "DeprecationWarning", "RuntimeWarning", "SyntaxError",
+           "NameError::UndefinedVariable", "LoadError::MissingFile", "NoMethodError::MissingMethod",
+           "ArgumentError::InvalidValue", "ArgumentError::MissingRequiredParameter", "IndexError::OutOfRange",
+           "ActiveRecord::RecordNotFound", "Mongoid::Errors::DocumentNotFound", "Redis::CommandError", "Net::ReadTimeout",
+           "Faraday::TimeoutError"
+        :warning
+      else
+        :error
+      end
+    end
+
+    def config
+      Errordeck.configuration
+    end
+
+    def server_name_env
+      # set server_name context
+      config.server_name || ENV.fetch("SERVER_NAME", nil)
+    end
+  end
+end

data/lib/errordeck.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "errordeck/version"
+require_relative "errordeck/configuration"
+Dir["#{File.dirname(__FILE__)}/errordeck/errordeck/**/*.rb"].sort.each { |file| require file }
+require_relative "errordeck/request_handler"
+require_relative "errordeck/wrapper"
+require_relative "errordeck/scrubber/scrubber"
+require_relative "errordeck/plugin_require"
+
+module Errordeck
+  class Error < StandardError; end
+
+  class << self
+    def info(message:, extra: nil)
+      generate_event(level: "info", message: message, extra: extra)
+    end
+
+    def warning(message:, extra: nil)
+      generate_event(level: "warning", message: message, extra: extra)
+    end
+
+    def error(message:, extra: nil)
+      generate_event(level: "error", message: message, extra: extra)
+    end
+
+    def fatal(message:, extra: nil)
+      generate_event(level: "fatal", message: message, extra: extra)
+    end
+
+    def generate_event(level:, message:, extra: nil, capture: true)
+      wrap(capture) do |b|
+        b.message(level, message, extra)
+      end
+    end
+
+    def message(level:, message:, extra: nil, capture: true)
+      wrap(capture) do |b|
+        b.message(level, message, extra)
+      end
+    end
+
+    def capture(exception:, user: nil, tags: nil, capture: true)
+      wrap(capture) do |b|
+        b.user_context = user if user
+        b.tags_context = tags if tags
+        b.capture(exception)
+      end
+    end
+
+    def wrap(capture = true)
+      wrapper = Wrapper.new
+      begin
+        yield(wrapper)
+        wrapper.send_event if capture
+      rescue Exception => e
+        wrapper.capture(e)
+        wrapper.send_event if capture
+        raise e
+      end
+    end
+  end
+end