debugmate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eb9597a1a66b25a3f9b7eb95f5bb9eb23bd9a64b19a59e90746ab6c53566f722
+  data.tar.gz: 62f5458450e7a11831b5389f66a0590265909e27ec07d80bf22e4dc20c48314f
+SHA512:
+  metadata.gz: e40d35a1bdd587f03d451ef5421babd974e5e1f04ee7e0c615706da47ac6c0779717613e4776b972007e91a2cc9d701d780c3712025b2a47139f52de3d44f6bf
+  data.tar.gz: 4b46cf9f78c1773157a58f6a685b564706743ca95654fe6189775d27f65796944f5d03f81828e999b53164c2f401dc1454bc057dc4af690edb966bce45e823c9

data/README.md

@@ -0,0 +1,184 @@
+# DebugMate
+Exception handling for Ruby on Rails
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "debugmate"
+```
+
+While the gem is not published in RubyGems, you can install from this repo directly:
+
+```ruby
+gem 'debugmate', :git => 'https://github.com/DebugMate/rails', :branch => 'main'
+```
+
+You can also clone this repo and point the path to the gem if you want to contribute or test locally:
+
+`../debugmate` is relative to the project and the folder name is the one you decided when cloning the repo.
+
+```ruby
+gem "debugmate", :path => "../debugmate"
+```
+
+And then execute:
+```bash
+bundle
+```
+
+Or install it yourself as:
+```bash
+gem install debugmate
+```
+
+## Usage
+Create `config/debugmate.yml` in your rails application and provide the following values:
+
+```yaml
+data:
+  domain: http://debugmate.test
+  enabled: true
+  token: 9dd70ed8-f3b2-4244-890e-c4f666d108ed
+```
+
+Create `config/initializers/debugmate.rb` with the following line:
+
+```ruby
+DEBUGMATE_CONFIG = YAML.load_file("#{Rails.root}/config/debugmate.yml")
+```
+
+## Get the last executed query with the exception
+
+To be able to get the query, you must add the following boilerplate code to the `debugmate.rb` initializer.
+
+This is the only way to get Rails to intercept the call for the moment:
+
+```ruby
+module ActiveRecord
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      # this allows us to call the original sql method. Ruby does copy the original method on the fly
+      alias_method :original_sql, :sql
+
+      def sql(event)
+        Debugmate::ExceptionHandler.last_executed_query = event.payload[:sql] if DEBUGMATE_CONFIG['data']['enabled'] === true
+        Debugmate::ExceptionHandler.last_executed_binds = event.payload[:binds] if DEBUGMATE_CONFIG['data']['enabled'] === true
+        original_sql(event)
+      end
+    end
+end
+```
+
+Edit `config/application.rb` to use Debugmate.
+
+Add the middleware inside the Application class, ideally as the last line, following the example:
+
+```ruby
+module Blog
+  class Application < Rails::Application
+    # --- Here is the exiting code ---
+
+    config.middleware.use Debugmate::ExceptionHandler
+  end
+end
+```
+
+You can check that your setup is correct by issuing the test command as follows:
+
+```bash
+rails debugmate:test
+```
+
+## Get the current User
+
+As there are a lot of ways an user can be retrieved and maybe even the application has no user at all, if you want
+to know the current user that caused the exception, you must provide a public method called `current_user` in your
+`ApplicationController`.
+
+This method must return a Hash with the `id, name and email`.
+
+You can follow the example. Debugmate only needs the Hash:
+
+```ruby
+class ApplicationController < ActionController::Base
+
+    def current_user
+        # --- some logic that gets the user for your application ---
+
+        user = {
+            id: 99,
+            name: "User from Rails",
+            email: "user@fromrails.com"
+        }
+    end
+
+end
+```
+
+## Sending exceptions manually to Debugmate
+
+If you want to catch an exception manually, you can do so using the `Publish` class. Just pass the exception and call
+`execute`
+
+```ruby
+def index
+  @articles = Article.test
+rescue => my_error
+  begin
+    Debugmate::Publish.new(my_error).execute
+  end
+end
+```
+
+### Sending information about the request
+
+If you want Debugmate to register more details about the exception, just pass the request along:
+
+```ruby
+def index
+  @articles = Article.test
+rescue => my_error
+  begin
+    Debugmate::Publish.new(my_error, request).execute
+  end
+end
+```
+
+### Sending extra info to Debugmate
+
+If you want to send some extra info about the exception, you can make use of the `extra_data` parameter. Debugmate will
+display it in its `Context` tab.
+
+```ruby
+def index
+    @articles = Article.test
+  rescue => my_error
+    begin
+      extra = {hello: 'world'}
+      Debugmate::Publish.new(my_error, request, extra).execute
+    end
+  end
+```
+
+## Running tests
+
+Go to the gem folder and run bundler to install the gem dependencies locally
+```bash
+bundle
+```
+
+To run the available tests, go to the gem folder and execute
+```bash
+bundle exec rspec
+```
+
+You can get the list of passing tests with the doc format:
+```bash
+bundle exec rspec --format doc
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/debugmate/context.rb

@@ -0,0 +1,140 @@
+require 'debugmate/curl'
+
+module Debugmate
+    class Context
+        attr_accessor :env, :extra_data
+
+        def initialize(request, exception, extra_data = nil)
+            @env = request if request.is_a? Hash
+            @env = request.env if defined? (request.env)
+
+            @exception = exception
+            @extra_data = extra_data
+        end
+
+        def app
+            controller = @env['action_dispatch.request.parameters']['controller'] if @env['action_dispatch.request.parameters'] && @env['action_dispatch.request.parameters']['controller']
+            action = @env['action_dispatch.request.parameters']['action'] if @env['action_dispatch.request.parameters'] && @env['action_dispatch.request.parameters']['action']
+
+            app = {
+                controller: controller,
+                route: {
+                    name: action,
+                    parameters: route_params
+                },
+                middlewares: {},
+                view: {
+                    name: nil,
+                    data: nil
+                }
+            }
+
+            app
+        end
+
+        def route_params
+            clean_params = {}
+
+            # based on https://github.com/rails/rails/blob/7-0-stable/actionpack/lib/action_dispatch/middleware/debug_view.rb
+            params = @env['action_dispatch.request.parameters'] if @env['action_dispatch.request.parameters']
+
+            clean_params = params.clone if params
+            clean_params.delete("action")
+            clean_params.delete("controller")
+            clean_params
+        end
+
+        def request
+            url = "#{@env['HTTP_HOST']}#{@env['PATH_INFO']}" if @env['HTTP_HOST'] && @env['PATH_INFO']
+            method = "#{@env['REQUEST_METHOD']}" if @env['REQUEST_METHOD']
+            url_params = @env['QUERY_STRING'] if @env['QUERY_STRING']
+
+            # query string to hash: https://stackoverflow.com/a/16695721/2465086
+            query_string = Hash[*url_params.split(/=|&/)] if url_params.is_a? String
+
+            body = route_params if method == 'POST'
+
+            curl = Curl.new(url_headers, route_params, url, method)
+
+            request_info = {
+                request: {
+                    url: url,
+                    method: method,
+                    curl: curl.parsed
+                },
+                headers: url_headers,
+                query_string: query_string ||= nil,
+                body: body ||= nil,
+                files: nil,
+                session: session,
+                cookies: {}
+            }
+
+            request_info
+        end
+
+        def url_headers
+            headers = {}
+
+            # Based on https://github.com/rails/rails/blob/7-0-stable/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
+            request = ActionDispatch::Request.new @env
+
+            # Headers are extracted using splat operator. This is based on https://github.com/rails/rails/blob/7-0-stable/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb
+            headers = request.env.slice(*request.class::ENV_METHODS) if @env.is_a? Hash
+
+            headers
+        end
+
+        def session
+            session = {}
+
+            request = ActionDispatch::Request.new @env
+
+            session = request.session.to_h
+
+            session
+        end
+
+        def environment
+            environment = [
+                {
+                    group: 'Ruby on Rails',
+                    variables: {
+                        version: Rails.version,
+                        locale: I18n.locale.to_s
+                    }
+                },
+                {
+                    group: 'App',
+                    variables: {
+                        environment: Rails.env,
+                        date_time: Rails.configuration.time_zone
+                    }
+                },
+                {
+                    group: 'System',
+                    variables: {
+                        ruby: RUBY_VERSION,
+                        os: RUBY_PLATFORM,
+                        server_software: @env['SERVER_SOFTWARE'],
+                        database_version: Rails.configuration.database_configuration[Rails.env]['adapter'],
+                        browser_version: @env['HTTP_USER_AGENT']
+                    }
+                }
+            ]
+
+            environment
+        end
+
+        def user
+            begin
+              user_controller = @env['action_controller.instance'] if @env['action_controller.instance']
+              user = user_controller.send(:current_user) if user_controller
+
+              user
+            rescue NoMethodError
+                nil
+            end
+        end
+    end
+end

data/lib/debugmate/curl.rb

@@ -0,0 +1,48 @@
+module Debugmate
+    class Curl
+        def initialize(headers, params, url, method)
+            @headers = headers
+            @params = params
+            @url = url
+            @method = method
+        end
+
+        def parsed
+            headers_clean = @headers.clone
+            headers_clean.delete("GATEWAY_INTERFACE")
+            headers_clean.delete("REMOTE_ADDR")
+            headers_clean.delete("SERVER_NAME")
+            headers_clean.delete("SERVER_PROTOCOL")
+            headers_clean.delete("ORIGINAL_SCRIPT_NAME")
+            headers_clean.delete("HTTP_VERSION")
+
+            headers_line = ""
+            headers_clean.each do |header|
+                value = header[1]
+                value = value.downcase unless header[0].downcase.include? 'token'
+
+                headers_line = headers_line + "-H '#{header[0].gsub(/HTTP_/, '').downcase}: #{value}' \\\n"
+            end
+
+            post_fields = ""
+            @params.each do |param|
+                if param[1].is_a? Hash
+                    param[1].each do |label, val|
+                        post_fields = post_fields + "-d '#{param[0]}[#{label}]=#{val}' \\\n"
+                    end
+                else
+                    post_fields = post_fields + "-d '#{param[0]}=#{param[1]}' \\\n"
+                end
+            end
+
+            curl = <<~CURL
+            curl '#{@url}' \\
+            -X #{@method} \\
+            #{headers_line.chop}
+            #{post_fields.chop}
+            CURL
+
+            curl
+        end
+    end
+end

data/lib/debugmate/handler.rb

@@ -0,0 +1,26 @@
+require 'debugmate/publish'
+
+module Debugmate
+    class Handler
+
+        def initialize(env, exception)
+            @env = env
+            @exception = exception
+        end
+
+        def capture
+
+            query_data = {
+                query: Debugmate::ExceptionHandler.last_executed_query.tr('"',"'"),
+                binds: Debugmate::ExceptionHandler.last_executed_binds
+            }
+
+            publish = Publish.new(@exception, @env, query_data).execute
+
+            Debugmate::ExceptionHandler.last_executed_query = ''
+            Debugmate::ExceptionHandler.last_executed_binds = {}
+
+            publish
+        end
+    end
+end

data/lib/debugmate/publish.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+require 'debugmate/context'
+require 'debugmate/trace'
+
+module Debugmate
+    class Publish
+        def initialize(exception, request = {}, extra_data = nil)
+            @exception = exception
+            @request = request
+            @extra_data = extra_data
+        end
+
+        def execute
+            uri = URI("#{DEBUGMATE_CONFIG['data']['domain']}/api/capture")
+      
+            headers = {
+                'X-DEBUGMATE-TOKEN' => DEBUGMATE_CONFIG['data']['token'],
+                'Content-Type' => 'application/json',
+                'Accept' => 'application/json'
+            }
+
+            result = Net::HTTP.post(uri, payload.to_json, headers)
+
+            result
+        end
+
+        def payload
+            context = Context.new(@request, @exception, @extra_data)
+
+            trace = Trace.new(@exception, @request)
+            
+            data = {
+                exception: @exception.class.to_s,
+                message: @exception.message,
+                file: trace.parsed[0][:file],
+                type: 'web',
+                trace: trace.parsed,
+                app: context.app,
+                request: context.request,
+                environment: context.environment,
+                user: context.user || [],
+                context: context.extra_data || []
+            }
+
+            data
+        end
+    end
+end

data/lib/debugmate/railtie.rb

@@ -0,0 +1,7 @@
+module Debugmate
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load 'tasks/debugmate_tasks.rake'
+    end
+  end
+end

data/lib/debugmate/trace.rb

@@ -0,0 +1,54 @@
+module Debugmate
+    class Trace
+      def initialize(exception, request = {})
+        @exception = exception
+        @env = request.is_a?(Hash) ? request : (request.env if request.respond_to?(:env))
+      end
+  
+      def parsed
+        wrapped = ActionDispatch::ExceptionWrapper.new(ActiveSupport::BacktraceCleaner.new, @exception)
+      
+        function = @env.dig('action_dispatch.request.parameters', 'action')
+  
+        source_to_show_id = wrapped.source_to_show_id
+        backtrace = @exception.backtrace
+  
+        trace = if source_to_show_id && backtrace
+          [{
+            file: backtrace[source_to_show_id].to_s,
+            line: wrapped.source_extracts.dig(source_to_show_id, :line_number),
+            function: function,
+            class: extract_class(backtrace[source_to_show_id]),
+            preview: wrapped.source_extracts.dig(source_to_show_id, :code)
+          }]
+        else
+          [{
+            file: backtrace&.first.to_s,
+            line: nil,
+            function: function,
+            class: extract_class(backtrace&.first),
+            preview: nil
+          }]
+        end
+  
+        trace
+      end
+  
+      private
+  
+      def extract_class(backtrace_line)
+        return "Unknown" if backtrace_line.nil?
+        
+        # Tenta extrair o nome da classe do backtrace
+        match = backtrace_line.match(/^(.+?):(\d+):in/)
+        if match
+          file_path = match[1]
+          class_name = File.basename(file_path, ".*").split("_").map(&:capitalize).join
+          class_name.empty? ? "Unknown" : class_name
+        else
+          "Unknown"
+        end
+      end
+    end
+end
+  

data/lib/debugmate/version.rb

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

data/lib/debugmate.rb

@@ -0,0 +1,52 @@
+require "debugmate/version"
+require "debugmate/railtie"
+require "debugmate/handler"
+
+require "net/http"
+
+module Debugmate
+  class ExceptionHandler
+    mattr_reader :last_executed_binds
+    mattr_accessor :last_executed_query
+
+    @@last_executed_query = ""
+    @@last_executed_binds = {}
+
+    def initialize(app)
+        @app = app
+    end
+
+    def call(env)
+        @app.call(env)
+    rescue StandardError => raised
+        Handler.new(env, raised).capture if DEBUGMATE_CONFIG['data']['enabled'] === true
+        raise
+    end
+
+    def self.send_test
+        puts "Please check that you have your initializer defined with the DEBUGMATE_CONFIG constant" unless defined? DEBUGMATE_CONFIG
+        raise TestException
+    rescue StandardError => raised
+        response = Handler.new({'REQUEST_METHOD' => "GET"}, raised).capture if DEBUGMATE_CONFIG['data']['enabled'] === true
+        puts "We couldn't reach Debugmate Server at #{DEBUGMATE_CONFIG['data']['domain']}" unless response.is_a? Net::HTTPSuccess
+        puts "Debugmate reached successfully. We sent a test Exception that has been registered." if response.is_a? Net::HTTPSuccess
+    end
+
+    def self.last_executed_binds=(binds)
+      if binds.is_a? Array
+        binds.each do |bind|
+          name = bind.name
+          value = bind.value
+          @@last_executed_binds[name] = value
+        end
+      end
+    end
+
+  end
+
+  class TestException < StandardError
+    def message
+        "Test generated by the debugmate:test rails command"
+    end
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: debugmate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- DevSquad
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec-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'
+description: DebugMate provides powerful error tracking and debugging tools for Rails
+  applications.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/debugmate.rb
+- lib/debugmate/context.rb
+- lib/debugmate/curl.rb
+- lib/debugmate/handler.rb
+- lib/debugmate/publish.rb
+- lib/debugmate/railtie.rb
+- lib/debugmate/trace.rb
+- lib/debugmate/version.rb
+homepage: https://github.com/DebugMate/debugmate
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/DebugMate/debugmate
+  source_code_uri: https://github.com/DebugMate/debugmate
+  changelog_uri: https://github.com/DebugMate/debugmate/CHANGELOG.md
+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.5.11
+signing_key:
+specification_version: 4
+summary: Error tracking and monitoring for Ruby on Rails applications.
+test_files: []