exceptio 0.2.0

data/app/views/exceptio/exceptions/show.html.slim

@@ -0,0 +1,74 @@
+= sts.card :exceptio_exceptions, title: @exception.exception_class, description: @exception.code_location do |card|
+  - card.with_action
+    = link_to exception_path(@exception), data: { turbo_method: :delete, turbo_confirm: 'Are you sure?' }, class: 'button'
+      i.fas.fa-trash
+  - card.with_tab :exception, padding: true
+    .grid.grid-cols-4.gap-4.mb-4
+      .col-span-3
+        h1 = @exception.exception_class
+        pre.text-xs style="height: 400px; overflow-y: scroll;"
+          code
+            = @exception.message
+      .col-span-1
+        = column_chart @exception.instances.group_by_day(:created_at).count
+
+    .grid.grid-cols-4.gap-4
+      .col-span-3
+        ul role="list" class="space-y-6"
+          = render partial: 'trace_element', collection: @exception.detailed_backtrace.map(&:symbolize_keys)
+      .col-span-1
+
+  - card.with_tab :instances, padding: true, badge: @exception.instances_count
+    .flow-root
+      ul.list-none.-mb-8
+        - @exception.instances.order(created_at: :desc).limit(10).each do |instance|
+          li
+            .relative.pb-8
+              span.absolute.left-5.top-5.-ml-px.h-full.w-0.5.bg-gray-200
+              .relative.flex.items-start.space-x-3
+                .relative
+                  .flex.h-10.w-10.items-center.justify-center.rounded-full.bg-gray-100.ring-8.ring-white
+                    - if instance.job?
+                      i.fas.fa-dumbbell
+                    - elsif instance.web?
+                      i.fas.fa-globe
+
+                .min-w-0.flex-1
+                  div
+                    .text-sm
+                      // could be a linK?
+                      .font-medium.text-gray-900
+                        = instance.message
+                    p.mt-1.text-sm.text-gray-500
+                      = ln(instance.created_at)
+                    - if instance.browser
+                      span.mr-1
+                        - if instance.browser.chrome?
+                          i.fab.fa-chrome
+                        - elsif instance.browser.firefox?
+                          i.fab.fa-chrome
+                        - elsif instance.browser.edge?
+                          i.fab.fa-edge
+                        - else
+                          i.fab.fa-safari
+                      span.mr-1
+                        - if instance.browser.platform.windows?
+                          i.fab.fa-windows
+                        - elsif instance.browser.platform.mac?
+                          i.fab.fa-apple
+                        - elsif instance.browser.platform.linux?
+                          i.fab.fa-linux
+
+                  .mt-2.text-sm.text-gray-700
+                    = sts.info class: "grid grid-cols-1 gap-4 sm:grid-cols-3 mt-5" do |info|
+                      = info.with_item :path, class: "sm:col-span-1"
+                        - instance.request_env['REQUEST_URI']
+                      = info.with_item :method, class: "sm:col-span-1"
+                        - instance.request_env['REQUEST_METHOD']
+                      = info.with_item :remote_ip, class: "sm:col-span-1"
+                        - instance.request_env['REMOTE_ADDR']
+                      = info.with_item :queue, class: "sm:col-span-1"
+                        - instance.job['queue']
+                    /= instance.context
+
+

data/app/views/exceptio/instances/_instance.html.slim

@@ -0,0 +1,48 @@
+.grid.grid-cols-1.gap-4.px-6.py-6.sm:grid-cols-3
+  .sm:col-span-3
+    = sts.info class: "grid grid-cols-1 gap-4 sm:grid-cols-2" do |info|
+      = info.with_item :error, content: instance.message, class: "sm:col-span-1"
+      = info.with_item :created_at, content: ln(instance.created_at), class: "sm:col-span-1", icon: 'fal fa-calendar'
+      = info.with_item :exceptionable_id, content: instance.exceptio_exceptionable_id, class: "sm:col-span-1"
+      = info.with_item :exceptionable_type, content: instance.exceptio_exceptionable_type, class: "sm:col-span-1"
+    br
+    - instance.related_data.each do |data|
+      .col-span-1.sm:col-span-1
+        = data.first.class.name
+      .col-span-1.sm:col-span-1
+        = link_to(data.second)
+          = data.last
+    - instance.context.each do |field, value|
+      .col-span-1.sm:col-span-1
+        = sts.card(title: field) do |card|
+          textarea data-controller="editor" data-editor-target="textarea" data-editor-mode="ruby" data-editor-height="400px" data-editor-readonly="true" = value
+          - if field == "job"
+            - gids = []
+            - hashes = eval(value)["args"].compact.map {|a| a.is_a?(Hash) ?  a["arguments"] : nil}.compact.first&.select{|i| i.is_a?(Hash)} || []
+            - hashes.each do  |h|
+              - h.each do |h1, v1|
+                - if v1.is_a?(Hash)
+                  - gids << v1.values.first
+                - elsif v1.is_a?(String)
+                  - gids << v1
+              - gids = gids.select{|k| k.start_with?("gid://")}
+            - GlobalID::Locator.locate_many(gids).each do |thing|
+              - if thing.is_a?(User)
+                =  link_to(thing.name, admin_user_path(thing))
+              - elsif thing.is_a?(Account)
+                =  link_to(thing.name, admin_account_path(thing))
+              - elsif thing.is_a?(Location)
+                =  link_to(thing.name, admin_location_path(thing))
+              - elsif thing.is_a?(Order)
+                =  link_to(thing.name, order_path(thing))
+              - elsif thing.is_a?(Shipment)
+                =  link_to(thing.name, shipment_path(thing))
+              - elsif thing.is_a?(Nuntius::Message)
+                =  link_to(thing.transport.upcase, Nuntius::Engine.routes.url_helpers.admin_message_path(thing))
+              - elsif thing.is_a?(Integration)
+                = link_to(thing.name, admin_integration_path(thing))
+              - elsif thing.is_a?(Vorto::Flow)
+                = link_to(thing.name, Vorto::Engine.routes.url_helpers.flow_path(thing))
+              - elsif ![Exceptio::Instance].member?(thing.class)
+                = link_to(thing)
+              br

data/config/importmap.rb

@@ -0,0 +1,4 @@
+pin "exceptio", to: "exceptio/application.js", preload: false
+
+pin "chartkick", to: "chartkick.js"
+pin "Chart.bundle", to: "Chart.bundle.js"

data/config/locales/en.yml

@@ -0,0 +1,16 @@
+en:
+  exceptio:
+    exceptions:
+      index:
+        exceptions: Exceptions
+      show:
+        tabs:
+          main:
+            tab:
+              exception: Exceptions
+              instances: Instances
+        info_item:
+          main:
+            path: Path
+            method: Method
+            remote_ip: Extern IP

data/config/locales/nl.yml

@@ -0,0 +1,16 @@
+nl:
+  exceptio:
+    exceptions:
+      index:
+        exceptions: Execpties
+      show:
+        tabs:
+          main:
+            tab:
+              exception: Exceptie
+              instances: Instanties
+        info_item:
+          main:
+            path: Pad
+            method: Methode
+            remote_ip: Extern IP

data/config/routes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Exceptio::Engine.routes.draw do
+  root to: 'exceptions#index'
+  resources :exceptions do
+    collection do
+      post :delete_all
+    end
+  end
+end

data/db/migrate/20190729153259_create_exceptions.rb

@@ -0,0 +1,23 @@
+class CreateExceptions < ActiveRecord::Migration[5.2]
+  def change
+    create_table :exceptio_exceptions, id: :uuid do |t|
+      t.string :exception_class, null: false
+      t.string :code_location, null: false
+      t.jsonb :detailed_backtrace, default: [], null: false
+      t.integer :instances_count, default: 0, null: false
+
+      t.timestamp :last_instance_at
+      t.timestamps null: false
+    end
+
+    create_table :exceptio_instances do |t|
+      t.uuid :exception_id, null: false
+      t.string :message, null: false
+      t.string :related_sgids, array: true, default: [], null: false
+      t.string :log_lines, array: true, default: [], null: false
+      t.jsonb :context, default: [], null: false
+
+      t.timestamps null: false
+    end
+  end
+end

data/db/migrate/20201027102223_add_indices1.rb

@@ -0,0 +1,8 @@
+class AddIndices1 < ActiveRecord::Migration[5.2]
+  def change
+    add_index :exceptio_exceptions, :created_at
+    add_index :exceptio_exceptions, :updated_at
+    add_index :exceptio_exceptions, :last_instance_at
+    add_index :exceptio_instances, :exception_id
+  end
+end

data/db/migrate/20221229092150_add_ownable_to_instance.rb

@@ -0,0 +1,6 @@
+class AddOwnableToInstance < ActiveRecord::Migration[7.0]
+  def change
+    add_column :exceptio_instances, :exceptio_exceptionable_id, :uuid
+    add_column :exceptio_instances, :exceptio_exceptionable_type, :string
+  end
+end

data/lib/exceptio/engine.rb

@@ -0,0 +1,28 @@
+require 'slim'
+require 'tailwindcss-rails'
+require "importmap-rails"
+require "turbo-rails"
+require "stimulus-rails"
+
+require 'chartkick'
+require 'groupdate'
+
+module Exceptio
+  class Engine < ::Rails::Engine
+    isolate_namespace Exceptio
+
+    initializer 'exceptio.assets' do |app|
+      app.config.assets.paths << root.join("app/javascript")
+      app.config.assets.paths << root.join("app/components")
+      app.config.assets.paths << Exceptio::Engine.root.join("vendor/javascript")
+      app.config.assets.precompile += %w[exceptio_manifest]
+    end
+
+    initializer 'exceptio.importmap', before: "importmap" do |app|
+      app.config.importmap.paths << root.join("config/importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/javascript")
+      app.config.importmap.cache_sweepers << root.join("app/components")
+      app.config.importmap.cache_sweepers << Exceptio::Engine.root.join("vendor/javascript")
+    end
+  end
+end

data/lib/exceptio/rack/rails_instrumentation.rb

@@ -0,0 +1,52 @@
+require "rack"
+
+module Exceptio
+  # @api private
+  module Rack
+    class RailsInstrumentation
+      def initialize(app, options = {})
+        # Exceptio.logger.debug 'Initializing Exceptio::Rack::RailsInstrumentation'
+        @app = app
+        @options = options
+      end
+
+      def call(env)
+        if Exceptio.active?
+          call_with_exceptio(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def call_with_exceptio(env)
+        request = ActionDispatch::Request.new(env)
+
+        recording = Exceptio::Recording.create(
+            request_id(env),
+            'http_request',
+            request,
+            :params_method => :filtered_parameters
+        )
+        begin
+          @app.call(env)
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          recording.set_error(error)
+          controller = env['action_controller.instance']
+          if controller
+            recording.set_metadata('action', "#{controller.class}##{controller.action_name}")
+          end
+          recording.set_metadata('path', request.path)
+          recording.set_metadata('method', request.request_method)
+          Exceptio::Recording.store!
+          raise error
+        ensure
+          Exceptio::Recording.clear_current_recording!
+        end
+      end
+
+      def request_id(env)
+        env['action_dispatch.request_id'] || SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/exceptio/railtie.rb

@@ -0,0 +1,19 @@
+Exceptio.logger.info("Loading Rails (#{Rails.version}) integration")
+
+require "exceptio/rack/rails_instrumentation"
+
+module Exceptio
+  # @api private
+  class Railtie < ::Rails::Railtie
+    initializer "exceptio.configure_rails_initialization" do |app|
+      Exceptio::Railtie.initialize_exceptio(app)
+    end
+
+    def self.initialize_exceptio(app)
+      app.middleware.insert_after(
+          ActionDispatch::DebugExceptions,
+          Exceptio::Rack::RailsInstrumentation
+      )
+    end
+  end
+end

data/lib/exceptio/recording.rb

@@ -0,0 +1,92 @@
+require "exceptio/rack/rails_instrumentation"
+
+module Exceptio
+  # @api private
+  class Recording
+
+    attr_reader :recording_id
+
+    class << self
+      def create(recording_id, namespace, request, options = {})
+        # Allow middleware to force a new recording
+        if options.include?(:force) && options[:force]
+          Thread.current[:exceptio_recording] = nil
+        end
+
+        # Check if we already have a running recording
+        if Thread.current[:exceptio_recording] != nil
+          # Log the issue and return the current recording
+          Exceptio.logger.debug "Trying to start new recording with id " \
+            "'#{recording_id}', but a recording with id '#{current.recording_id}' " \
+            "is already running. Using recording '#{current.recording_id}'."
+
+          # Return the current (running) recording
+          current
+        else
+          # Otherwise, start a new exceptio_recording
+          Thread.current[:exceptio_recording] = Exceptio::Recording.new(recording_id, namespace, request, options)
+        end
+      end
+
+      def current
+        Thread.current[:exceptio_recording]
+      end
+
+      def store!
+        current.store
+      rescue => e
+        Exceptio.logger.error("Failed to complete recording ##{current.recording_id}. #{e.message}")
+      ensure
+        clear_current_recording!
+      end
+
+      # Remove current recording from current Thread.
+      # @api private
+      def clear_current_recording!
+        Thread.current[:exceptio_recording] = nil
+      end
+    end
+
+    def initialize(recording_id, namespace, request, options = {})
+      @recording_id = recording_id
+      @action = nil
+      @namespace = namespace
+      @request = request
+      @tags = {}
+      @options = options
+      @options[:params_method] ||= :params
+      @error = nil
+      @metadata = {}
+    end
+
+    def set_error(error)
+      return unless error
+
+      backtrace = cleaned_backtrace(error.backtrace)
+      @error = { class_name: error.class.name, message: error.message.to_s, backtrace: backtrace || [] }
+    end
+
+    def set_metadata(key, value = '')
+      @metadata[key] = value
+    end
+
+    def cleaned_backtrace(backtrace)
+      if defined?(::Rails) && backtrace
+        ::Rails.backtrace_cleaner.clean(backtrace, nil)
+      else
+        backtrace
+      end
+    end
+
+    def environment
+      return {} unless request.respond_to?(:env)
+      return {} unless request.env
+
+      request.env
+    end
+
+    def store
+      Exceptio.logger.debug "recording: #{self.inspect}"
+    end
+  end
+end

data/lib/exceptio/version.rb

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

data/lib/exceptio.rb

@@ -0,0 +1,69 @@
+require "exceptio/engine"
+
+module Exceptio
+  class Error < StandardError; end
+
+  class Configuration
+    attr_accessor :base_controller, :max_occurences
+    attr_writer   :logger, :related_sgids, :sgid_to_object_url_name, :context_details, :after_exception, :layout, :admin_layout
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::WARN
+      @base_controller = '::ApplicationController'
+      @context_details = -> { {} }
+      @related_sgids = -> { [] }
+      @sgid_to_object_url_name = -> { nil }
+      @after_exception = ->(exception, instance) {}
+      @max_occurences = 100
+      @layout = 'application'
+      @admin_layout = 'application'
+    end
+
+    # Config: logger [Object].
+    def logger
+      @logger.is_a?(Proc) ? instance_exec(&@logger) : @logger
+    end
+
+    # Proc returning array of sgids of relevant objects, like  current user or account
+    def related_sgids
+      instance_exec(&@related_sgids) if @related_sgids.is_a?(Proc)
+    end
+
+    # Proc returning [object, path, name] for the specified sgid (path to and name of user or account)
+    def sgid_to_object_url_name(sgid)
+      instance_exec(sgid, &@sgid_to_object_url_name) if @sgid_to_object_url_name.is_a?(Proc)
+    end
+
+    # Proc returning extra environment details (hash) to be stored with the exception
+    def context_details
+      context = instance_exec(&@context_details) if @context_details.is_a?(Proc)
+      context || {}
+    end
+
+    def after_exception(exception, instance)
+      instance_exec(exception, instance, &@after_exception) if @after_exception.is_a?(Proc)
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def setup
+      yield config
+    end
+
+    def logger
+      config.logger
+    end
+
+    def active?
+      false
+    end
+  end
+end
+
+require "exceptio/railtie" if defined?(::Rails)
+require "exceptio/recording"