solid_errors 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3f112f7c3ae7a71fa1f7d92be55cfa8e6fff8263fdff9a0c406c1db46c37126
-  data.tar.gz: fccfcd6e806e1f3fd17db5c89cc30f2c35302e6dc64b0a386f417bf1d28f8106
+  metadata.gz: 389a4c6c9c7910c471dfc93caf7003790e1afa6c0a6781f010d6453b99731ec2
+  data.tar.gz: 0ad0508538e6ff2f523a865e4230ff371400a56b8e897b6078c47570dd71eccc
 SHA512:
-  metadata.gz: f9415aa986a5ba6ff7491527f4cb053415df72fe73b585bd877f47e8e5ca869ba866210d9e32aac80373c43578b7efa59545dac9f82f808576f8ef80d60582b5
-  data.tar.gz: 1d0dd34c0920999496cd57e5729f3f18da0ca8c729b557d182cb9a47cfa3e8c038f1756a8d75fe5f08424e49d86db8050f85d2783e59751e7e778cc54d0282df
+  metadata.gz: c91d2c051098cd1f3530592f76f85b9dffe8aa264f693950673f1ac8110a09f1c0b6afa86ec7eb3b071d52825899cf71cf17e75ad01f394639446df4fbf21fbd
+  data.tar.gz: 7947a0212c04437d205c822da7a0a96fccba64907d5ad3a062afe6919934767d4d533da0f977e6d48218b7c7f6bd9d992a10cf5d157c2a661154edb0921488bc

data/README.md

@@ -79,6 +79,9 @@ production:
 
 Then run `db:prepare` in production to ensure the database is created and the schema is loaded.
 
+> [!WARNING]
+> Use `db:prepare`, not `db:create` followed by `db:migrate`. Solid Errors ships a schema rather than migrations, so `db:migrate` leaves the errors database empty and then dumps that empty schema over `db/errors_schema.rb`. If that has happened, copy the schema back from [the install template](lib/generators/solid_errors/install/templates/db/errors_schema.rb) and run `db:prepare` again.
+
 Then mount the engine in your `config/routes.rb` file:
 ```ruby
 authenticate :user, -> (user) { user.admin? } do
@@ -151,19 +154,34 @@ Rails.error.handle(context: { user_id: user.id }, severity: :info) do
 end
 ```
 
+
+### What each occurrence records
+
+Every occurrence stores the backtrace and the error's context. Rails adds the current request or job to that context, and Solid Errors records it as:
+
+* **Requests:** the controller action (`UsersController#show`) and its params, with your `config.filter_parameters` applied.
+* **Background jobs:** the job class, its id and queue, and its arguments, also filtered.
+
+Any Active Record object in the context is stored as its [GlobalID](https://github.com/rails/globalid) (`gid://my-app/User/1`), so you can tell which record was involved. Add your own context with `Rails.error.set_context(...)` or the `context:` option shown above.
+
+Errors raised in background jobs reach Solid Errors when your job backend runs jobs inside the Rails executor, as Solid Queue, Sidekiq and GoodJob do. You don't need any extra setup for this.
 ### Configuration
 
-You can configure Solid Errors via the Rails configuration object, under the `solid_errors` key. Currently, 6 configuration options are available:
+You can configure Solid Errors via the Rails configuration object, under the `solid_errors` key. Currently, the following configuration options are available:
 
+* `enabled` - Enable or disable error tracking. Defaults to `true`. See [Disabling error tracking](#disabling-error-tracking) for more information.
 * `connects_to` - The database configuration to use for the Solid Errors database. See [Database Configuration](#database-configuration) for more information.
 * `username` - The username to use for HTTP authentication. See [Authentication](#authentication) for more information.
 * `password` - The password to use for HTTP authentication. See [Authentication](#authentication) for more information.
 * `sends_email` - Whether or not to send emails when an error occurs. See [Email notifications](#email-notifications) for more information.
 * `email_from` - The email address to send a notification from. See [Email notifications](#email-notifications) for more information.
 * `email_to` - The email address(es) to send a notification to. See [Email notifications](#email-notifications) for more information.
+* `email_every_occurrence` - Whether to email every occurrence (the default), or only new errors and resolved errors that occur again. See [Email notifications](#email-notifications) for more information.
 * `email_subject_prefix` - Prefix added to the subject line for email notifications. See [Email notifications](#email-notifications) for more information.
+* `email_subject` - A proc that builds the subject line for email notifications. See [Email notifications](#email-notifications) for more information.
 * `base_controller_class` - Specify a different controller as the base class for the Solid Errors controller. See [Authentication](#authentication) for more information.
 * `destroy_after` - If set, Solid Errors will periodically destroy resolved records that are older than the value specified. See [Automatically destroying old records](#automatically-destroying-old-records) for more information.
+* `ignored_errors` - Error classes, or their names, to never record, in addition to the built-in list in `SolidErrors::Subscriber::IGNORED_ERRORS`. For example, `config.solid_errors.ignored_errors = ["ActiveStorage::FileNotFoundError"]`.
 
 ### Database Configuration
 
@@ -191,6 +209,46 @@ Running Solid Errors in a separate database is recommended, but it's also possib
 
 You won't have multiple databases, so `database.yml` doesn't need to have the errors database configuration.
 
+#### Apps that use `schema_format = :sql`
+
+The installer writes `db/errors_schema.rb`, but an app with `config.active_record.schema_format = :sql` looks for `db/errors_structure.sql` for the errors database.
+
+On Rails 8.1 and later, keep the Ruby schema for the errors database only by setting `schema_format` on it in `config/database.yml`:
+
+```yaml
+production:
+  errors:
+    <<: *default
+    database: storage/production_errors.sqlite3
+    migrations_paths: db/errors_migrate
+    schema_format: ruby
+```
+
+On earlier Rails versions, create the errors database, load the Ruby schema into it, and dump it as SQL for your database adapter:
+
+```sh
+bin/rails db:create:errors
+bin/rails runner 'ActiveRecord::Tasks::DatabaseTasks.load_schema(ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "errors"), :ruby, "db/errors_schema.rb")'
+bin/rails db:schema:dump:errors
+```
+
+This writes `db/errors_structure.sql`, which you commit in place of `db/errors_schema.rb`.
+
+#### Disabling error tracking
+
+Solid Errors is enabled by default. If you want to disable error tracking in a specific environment, you can set `enabled` to `false`:
+
+```ruby
+# config/environments/development.rb
+config.solid_errors.enabled = false
+```
+
+When disabled, Solid Errors will not subscribe to the Rails error reporter and no errors will be recorded.
+
+Disable it in every environment that loads the gem but has no errors database, such as development or test. Otherwise Solid Errors records errors to the primary database, fails with `Could not find table 'solid_errors'`, and in development and test that failure can hide the error you were looking for.
+
+Configuration belongs in `config/environments/<environment>.rb`, not in `config/<environment>.rb`, which Rails does not load.
+
 #### Authentication
 
 Solid Errors does not restrict access out of the box. You must secure the dashboard yourself. However, it does provide basic HTTP authentication that can be used with basic authentication or Devise. All you need to do is setup a username and password.
@@ -233,14 +291,14 @@ Solid Errors _can_ send email notifications whenever an error occurs, if your ap
 
 There are two ways to configure email notifications. First, you can use environment variables:
 
-```ruby
-ENV["SOLIDERRORS_SEND_EMAILS"] = true # defaults to false
-ENV["SOLIDERRORS_EMAIL_FROM"] = "errors@myapp.com" # defaults to "solid_errors@noreply.com"
-ENV["SOLIDERRORS_EMAIL_TO"] = "devs@myapp.com" # no default, must be set
-ENV["SOLIDERRORS_EMAIL_SUBJECT_PREFIX"] = "[Application name][Environment]" # no default, optional
+```sh
+SOLIDERRORS_SEND_EMAILS=true # defaults to false
+SOLIDERRORS_EMAIL_FROM=errors@myapp.com # defaults to solid_errors@noreply.com
+SOLIDERRORS_EMAIL_TO=devs@myapp.com # no default, must be set
+SOLIDERRORS_EMAIL_SUBJECT_PREFIX="[Application name][Environment]" # no default, optional
 ```
 
-Second, you can set the values via the configuration object:
+Second, you can set the values via the configuration object, which takes precedence over the environment variables:
 
 ```ruby
 # Set authentication credentials and optional subject prefix for Solid Errors
@@ -252,6 +310,57 @@ config.solid_errors.email_subject_prefix = "[#{Rails.application.name}][#{Rails.
 
 If you have set `send_emails` to `true` and have set an `email_to` address, Solid Errors will send an email notification whenever an error occurs. If you have not set `send_emails` to `true` or have not set an `email_to` address, Solid Errors will not send any email notifications.
 
+To be emailed only when an error is new, or when a resolved error occurs again, rather than for every occurrence:
+
+```ruby
+config.solid_errors.email_every_occurrence = false # defaults to true
+```
+
+The subject names the error, and says when a resolved error has occurred again (`🔥 TimeoutError (reopened)`). To build it yourself, set `email_subject` to a proc. It is called with the error, the occurrence, and `reason`: `:created` or `:reopened` when the occurrence opened its error, `nil` for any other. `email_subject_prefix` is still added in front of what it returns.
+
+```ruby
+config.solid_errors.email_subject = ->(error:, occurrence:, reason:) {
+  # Counting up to this occurrence, rather than all of them, gives the same answer however late the email is sent
+  count = error.occurrences.where(id: ..occurrence.id).count
+  subject = "#{error.severity_emoji} #{error.exception_class}"
+
+  case reason
+  when :reopened then "🔄 REOPENED: #{subject}"
+  when :resolved then "✅ RESOLVED: #{error.exception_class}"
+  else count.in?([10, 100, 1_000]) ? "#{subject} (#{count.ordinalize} occurrence)" : subject
+  end
+}
+```
+
+The error email can also be sent for events of your own, such as an error being resolved or occurring unusually often. Whatever reason you pass reaches `email_subject`, as `:resolved` does in the example above:
+
+```ruby
+# config/initializers/solid_errors.rb
+ActiveSupport::Notifications.subscribe("error_resolved.solid_errors") do |event|
+  occurrence = event.payload[:error].occurrences.last
+  SolidErrors::ErrorMailer.error_occurred(occurrence, :resolved).deliver_later if occurrence && SolidErrors.send_emails?
+end
+```
+
+#### Lifecycle events
+
+Solid Errors publishes [Active Support notifications](https://guides.rubyonrails.org/active_support_instrumentation.html) once each change is committed, so you can send errors to Slack, a webhook or anywhere else:
+
+| Event | When | Payload |
+| --- | --- | --- |
+| `error_created.solid_errors` | An error is recorded for the first time | `:error`, `:occurrence` |
+| `error_reopened.solid_errors` | A resolved error occurs again | `:error`, `:occurrence` |
+| `error_resolved.solid_errors` | An error is marked as resolved | `:error` |
+| `occurrence_created.solid_errors` | Any occurrence is recorded, including those above | `:error`, `:occurrence` |
+
+```ruby
+# config/initializers/solid_errors.rb
+ActiveSupport::Notifications.subscribe(/\Aerror_(created|reopened)\.solid_errors\z/) do |event|
+  error = event.payload[:error]
+  SlackNotifier.post("#{error.exception_class}: #{error.message}")
+end
+```
+
 #### Automatically destroying old records
 
 Setting `destroy_after` to a duration will allow Solid Errors to be self-maintaining by peridically destroying **resolved** records that are older than that value. The value provided must respond to `.ago`.
@@ -266,6 +375,21 @@ config.solid_errors.destroy_after = 30.days
 config.solid_errors.destroy_after = 6.months
 ```
 
+#### Checking the schema after an upgrade
+
+When a release changes the schema, [UPGRADE.md](UPGRADE.md) describes the migration. To have your test suite fail until you've applied it, assert that the errors database has everything the installed version uses:
+
+```ruby
+# test/solid_errors_test.rb
+require "test_helper"
+
+class SolidErrorsTest < ActiveSupport::TestCase
+  test "the errors database is up to date" do
+    assert SolidErrors.migrated?
+  end
+end
+```
+
 ### Examples
 
 There are only two screens in the dashboard.
@@ -348,6 +472,11 @@ You can always take control of the views by creating your own views and/or parti
 </html>
 ```
 
+
+### Locales
+
+The dashboard is written in English and renders in English whenever your app allows the `:en` locale. If `config.i18n.available_locales` leaves out `:en`, the dashboard renders in your app's locale instead, and you will need to provide the `datetime.distance_in_words.short` translations from [`config/locales/en.yml`](config/locales/en.yml) in that locale.
+
 ## Sponsors
 
 <p align="center">
@@ -376,4 +505,3 @@ The gem is available as open source under the terms of the [MIT License](https:/
 ## Code of Conduct
 
 Everyone interacting in the SolidErrors project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/fractaledmind/solid_errors/blob/main/CODE_OF_CONDUCT.md).
-

data/app/controllers/solid_errors/errors_controller.rb

@@ -1,6 +1,6 @@
 module SolidErrors
   class ErrorsController < ApplicationController
-    around_action :force_english_locale!
+    around_action :use_english_when_available
 
     before_action :set_error, only: %i[show update destroy]
 
@@ -53,7 +53,10 @@ module SolidErrors
       @error = Error.find(params[:id])
     end
 
-    def force_english_locale!(&action)
+    # The dashboard's strings ship in English only; apps that don't allow :en keep their own locale
+    def use_english_when_available(&action)
+      return action.call unless I18n.locale_available?(:en)
+
       I18n.with_locale(:en, &action)
     end
 

data/app/mailers/solid_errors/error_mailer.rb

@@ -8,15 +8,19 @@ module SolidErrors
           Rails.error.report(exception, handled: true, source: "solid_errors.error_mailer")
         end
       end
+
+      helper_method :occurrence_url
     end
 
-    def error_occurred(occurrence)
+    # reason is passed on to SolidErrors.email_subject: :created or :reopened when the occurrence
+    # opened its error, or whatever an app sending this email for its own events passes
+    def error_occurred(occurrence, reason = nil)
       unless defined?(ActionMailer::Base)
         raise "ActionMailer is not available. Make sure that you require \"action_mailer/railtie\" in application.rb"
       end
       @occurrence = occurrence
       @error = occurrence.error
-      subject = "#{@error.severity_emoji} #{@error.exception_class}"
+      subject = SolidErrors.email_subject.call(error: @error, occurrence: @occurrence, reason: reason&.to_sym)
       if SolidErrors.email_subject_prefix.present?
         subject = [SolidErrors.email_subject_prefix, subject].join(" ").squish!
       end
@@ -26,5 +30,14 @@ module SolidErrors
         to: SolidErrors.email_to
       )
     end
+
+    private
+
+    # Optional: an app without default_url_options[:host] still gets the email, just unlinked
+    def occurrence_url
+      public_send(SolidErrors.url_helper_name).error_url(@error, **SolidErrors.url_options, anchor: "occurrence_#{@occurrence.id}")
+    rescue ArgumentError, NoMethodError, ActionController::UrlGenerationError
+      nil
+    end
   end
 end

data/app/models/solid_errors/error.rb

@@ -30,6 +30,8 @@ module SolidErrors
     scope :resolved, -> { where.not(resolved_at: nil) }
     scope :unresolved, -> { where(resolved_at: nil) }
 
+    after_update_commit :publish_resolved, if: -> { saved_change_to_resolved_at? && resolved? }
+
     def severity_emoji
       SEVERITY_TO_EMOJI[severity.to_sym]
     end
@@ -53,5 +55,46 @@ module SolidErrors
     def resolved?
       resolved_at.present?
     end
+
+    def to_markdown
+      md = ""
+      md << "## Exception: #{exception_class}\n"
+      md << "**Severity:** #{severity} | **Source:** #{source}\n\n"
+      md << "### Message\n#{message}\n"
+
+      occurrence = occurrences.order(created_at: :desc).first
+      return md unless occurrence
+
+      backtrace = occurrence.parsed_backtrace
+
+      md << "\n### Backtrace\n"
+      backtrace.lines.each do |line|
+        md << (line.filtered_method ? line.to_s : line.unparsed_line) << "\n"
+      end
+
+      app_lines = backtrace.application_lines
+      if app_lines.any?
+        md << "\n### Source Context\n"
+        app_lines.each do |line|
+          md << "#### #{line}\n"
+          md << "```ruby\n"
+          line.source.each { |n, code| md << "#{n}: #{code.chomp}\n" }
+          md << "```\n\n"
+        end
+      end
+
+      if occurrence.context.present?
+        md << "### Request Context\n"
+        occurrence.context.each { |k, v| md << "- #{k}: #{v}\n" }
+      end
+
+      md
+    end
+
+    private
+
+    def publish_resolved
+      ActiveSupport::Notifications.instrument("error_resolved.solid_errors", error: self)
+    end
   end
 end

data/app/models/solid_errors/occurrence.rb

@@ -5,7 +5,11 @@ module SolidErrors
     # Adapters that report the json column as text (MariaDB) would otherwise store Hash#inspect
     attribute :context, :json
 
-    after_create_commit :send_email, if: -> { SolidErrors.send_emails? && SolidErrors.email_to.present? }
+    # :created or :reopened, set by the subscriber when this occurrence opens its error
+    attr_accessor :opens_error
+
+    after_create_commit :send_email, if: -> { SolidErrors.send_emails? && (SolidErrors.email_every_occurrence || opens_error) }
+    after_create_commit :publish_events
     after_create_commit :clear_resolved_errors, if: :should_clear_resolved_errors?
 
     # The parsed exception backtrace. Lines in this backtrace that are from installed gems
@@ -24,8 +28,15 @@ module SolidErrors
       Backtrace.parse(backtrace)
     end
 
+    def publish_events
+      payload = {error: error, occurrence: self}
+      ActiveSupport::Notifications.instrument("error_#{opens_error}.solid_errors", payload) if opens_error
+      ActiveSupport::Notifications.instrument("occurrence_created.solid_errors", payload)
+    end
+
     def send_email
-      ErrorMailer.error_occurred(self).deliver_later
+      # Passed along rather than read off the occurrence, which the mailer job loads afresh without it
+      ErrorMailer.error_occurred(self, opens_error).deliver_later
     end
 
     def clear_resolved_errors

data/app/views/layouts/solid_errors/application.html.erb

@@ -9,6 +9,9 @@
   </head>
   <body class="h-full flex flex-col pb-4">
     <main class="grow container mx-auto mt-4">
+      <% if defined?(main_app.root_path) %>
+        <%= link_to "← Back to main app", main_app.root_path, class: "text-sm text-blue-500 hover:underline decoration-blue-500" %>
+      <% end %>
       <%= content_for?(:content) ? yield(:content) : yield %>
     </main>
 
@@ -51,6 +54,87 @@
       document.querySelectorAll('[data-controller="fade"]').forEach(element => {
         fadeOut(element);
       });
+
+      // Backtrace filter toggle functionality
+      (function() {
+        const STORAGE_KEY = 'solid_errors_backtrace_filter';
+
+        function toggleBacktrace(button) {
+          const filter = button.getAttribute('data-backtrace-toggle');
+          const occurrenceId = button.getAttribute('data-occurrence-id');
+
+          // Toggle visibility
+          const appTrace = document.getElementById(`backtrace-application-${occurrenceId}`);
+          const fullTrace = document.getElementById(`backtrace-full-${occurrenceId}`);
+
+          if (filter === 'application') {
+            appTrace.removeAttribute('hidden');
+            fullTrace.setAttribute('hidden', '');
+          } else {
+            appTrace.setAttribute('hidden', '');
+            fullTrace.removeAttribute('hidden');
+          }
+
+          // Update button states for this occurrence
+          const occurrenceButtons = document.querySelectorAll(`[data-occurrence-id="${occurrenceId}"][data-backtrace-toggle]`);
+          occurrenceButtons.forEach(btn => {
+            if (btn === button) {
+              btn.classList.add('border-blue-500', 'text-blue-500');
+              btn.classList.remove('border-transparent', 'text-gray-500');
+            } else {
+              btn.classList.remove('border-blue-500', 'text-blue-500');
+              btn.classList.add('border-transparent', 'text-gray-500');
+            }
+          });
+
+          // Remember the choice; storage can be unavailable (private browsing)
+          try { sessionStorage.setItem(STORAGE_KEY, filter); } catch (e) {}
+        }
+
+        // Initialize on page load
+        let savedFilter = 'application';
+        try { savedFilter = sessionStorage.getItem(STORAGE_KEY) || savedFilter; } catch (e) {}
+
+        // Apply saved filter to all occurrences
+        if (savedFilter === 'full') {
+          document.querySelectorAll('[id^="backtrace-application-"]').forEach(el => el.setAttribute('hidden', ''));
+          document.querySelectorAll('[id^="backtrace-full-"]').forEach(el => el.removeAttribute('hidden'));
+
+          // Update button states
+          document.querySelectorAll('[data-backtrace-toggle]').forEach(btn => {
+            const filter = btn.getAttribute('data-backtrace-toggle');
+            if (filter === savedFilter) {
+              btn.classList.add('border-blue-500', 'text-blue-500');
+              btn.classList.remove('border-transparent', 'text-gray-500');
+            } else {
+              btn.classList.remove('border-blue-500', 'text-blue-500');
+              btn.classList.add('border-transparent', 'text-gray-500');
+            }
+          });
+        }
+
+        // Attach event listeners
+        document.querySelectorAll('[data-backtrace-toggle]').forEach(button => {
+          button.addEventListener('click', function() {
+            toggleBacktrace(this);
+          });
+        });
+      })();
+
+      var copyBtn = document.getElementById('copy-markdown');
+      if (copyBtn) {
+        copyBtn.addEventListener('click', function() {
+          var text = document.getElementById('error-markdown').content.textContent;
+          var span = copyBtn.querySelector('span');
+          var originalText = span.textContent;
+          navigator.clipboard.writeText(text).then(function() {
+            span.textContent = 'Copied!';
+            setTimeout(function() { span.textContent = originalText; }, 2000);
+          }).catch(function(err) {
+            alert('Failed to copy: ' + err);
+          });
+        });
+      }
     </script>
   </body>
 </html>

data/app/views/solid_errors/error_mailer/error_occurred.html.erb

@@ -1,17 +1,169 @@
 <html>
 <head>
   <title>Solid Errors | <%= @error.severity_emoji %> <%= @error.exception_class %></title>
-  <%= render "layouts/solid_errors/style" %>
+  <style>
+    body {
+      padding: 20px;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    }
+    .email-header {
+      margin-bottom: 16px;
+    }
+    .email-header h1 {
+      font-size: 20px;
+      font-weight: 700;
+      margin: 0 0 8px 0;
+    }
+    .email-header h1 a {
+      color: #1f2937;
+      text-decoration: none;
+    }
+    .email-header h1 a:hover {
+      text-decoration: underline;
+    }
+    .email-link {
+      font-size: 14px;
+      color: #2563eb;
+      text-decoration: none;
+      margin-bottom: 12px;
+      display: inline-block;
+    }
+    .error-message {
+      background: #f3f4f6;
+      padding: 12px;
+      border-radius: 4px;
+      margin: 12px 0;
+      font-family: monospace;
+      font-size: 13px;
+      white-space: pre-wrap;
+    }
+    .info-table {
+      width: auto;
+      border-collapse: collapse;
+      margin: 12px 0;
+      font-size: 13px;
+    }
+    .info-table td {
+      padding: 4px 8px;
+      border-bottom: 1px solid #e5e7eb;
+    }
+    .info-table td:first-child {
+      font-weight: 600;
+      white-space: nowrap;
+      vertical-align: top;
+    }
+    .backtrace {
+      background: #1e293b;
+      color: #fff;
+      padding: 12px;
+      border-radius: 4px;
+      margin: 12px 0;
+      font-family: 'Monaco', 'Courier New', monospace;
+      font-size: 12px;
+      line-height: 1.4;
+      overflow-x: auto;
+    }
+    .backtrace-line {
+      margin: 2px 0;
+    }
+    .backtrace-highlight {
+      background: #374151;
+      margin-left: -12px;
+      margin-right: -12px;
+      padding-left: 12px;
+      padding-right: 12px;
+    }
+    .context-table {
+      width: auto;
+      border-collapse: collapse;
+      margin: 12px 0;
+      font-size: 13px;
+    }
+    .context-table th {
+      background: #f3f4f6;
+      padding: 6px 8px;
+      text-align: left;
+      font-weight: 600;
+      border: 1px solid #e5e7eb;
+      white-space: nowrap;
+    }
+    .context-table td {
+      padding: 6px 8px;
+      border: 1px solid #e5e7eb;
+      font-family: monospace;
+      font-size: 12px;
+    }
+    .context-table td:first-child {
+      white-space: nowrap;
+    }
+    .section-title {
+      font-weight: 700;
+      font-size: 14px;
+      margin: 16px 0 8px 0;
+    }
+  </style>
 </head>
 <body>
-  <%= render "solid_errors/errors/error",
-        error: @error,
-        show_actions: false %>
 
-  <br>
-  <br>
+  <div class="email-header">
+    <h1>
+      <%= @error.severity_emoji %>
+      <%= @error.exception_class %>
+      from <em><%= @error.source %></em>
+    </h1>
+    <% if (url = occurrence_url) %>
+      <a href="<%= url %>" class="email-link">View in Solid Errors &rarr;</a>
+    <% end %>
+  </div>
 
-  <%= render "solid_errors/occurrences/occurrence",
-        occurrence: @occurrence %>
+  <div class="error-message"><%= @error.message %></div>
+
+  <table class="info-table">
+    <tr>
+      <td>Severity</td>
+      <td><%= @error.severity_emoji %> <%= @error.severity %></td>
+    </tr>
+    <tr>
+      <td>Status</td>
+      <td><%= @error.status_emoji %> <%= @error.status %></td>
+    </tr>
+    <tr>
+      <td>Occurred at</td>
+      <td><%= @occurrence.created_at.strftime("%Y-%m-%d %H:%M:%S %Z") %></td>
+    </tr>
+  </table>
+
+  <% if @occurrence.context&.any? %>
+    <div class="section-title">Context</div>
+    <table class="context-table">
+      <thead>
+        <tr>
+          <th>Key</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @occurrence.context.each do |key, value| %>
+          <tr>
+            <td><%= key %></td>
+            <td><%= value %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% end %>
+
+  <div class="section-title">Backtrace</div>
+  <div class="backtrace">
+    <% @occurrence.parsed_backtrace.lines.each_with_index do |line, i| %>
+      <div class="backtrace-line <%= i.zero? ? 'backtrace-highlight' : '' %>">
+        <% if line.filtered_file %>
+<span style="color: #9ca3af;"><%= File.dirname(line.filtered_file) %>/</span><span style="color: #60a5fa; font-weight: 500;"><%= File.basename(line.filtered_file) %></span>:<span style="color: #fff; font-weight: 500;"><%= line.filtered_number %></span> <span style="color: #9ca3af;">in</span> <span style="color: #34d399;"><%= line.filtered_method %></span>
+        <% else %>
+<span style="color: #9ca3af;"><%= line.unparsed_line %></span>
+        <% end %>
+      </div>
+    <% end %>
+  </div>
 </body>
 </html>

data/app/views/solid_errors/error_mailer/error_occurred.text.erb

@@ -0,0 +1,32 @@
+<%= @error.severity_emoji %> <%= @error.exception_class %> from <%= @error.source %>
+================================================================================
+
+<%= @error.message %>
+
+<% if (url = occurrence_url) %>
+View in Solid Errors: <%= url %>
+<% end %>
+
+DETAILS
+--------------------------------------------------------------------------------
+Severity:     <%= @error.severity_emoji %> <%= @error.severity %>
+Status:       <%= @error.status_emoji %> <%= @error.status %>
+Occurred at:  <%= @occurrence.created_at.strftime("%Y-%m-%d %H:%M:%S %Z") %>
+
+<% if @occurrence.context&.any? %>
+CONTEXT
+--------------------------------------------------------------------------------
+<% @occurrence.context.each do |key, value| %>
+<%= key.to_s.ljust(20) %> <%= value %>
+<% end %>
+
+<% end %>
+BACKTRACE
+--------------------------------------------------------------------------------
+<% @occurrence.parsed_backtrace.lines.each_with_index do |line, i| %>
+<% if line.filtered_file %>
+<%= i.zero? ? '>>>' : '   ' %> <%= File.join(File.dirname(line.filtered_file), File.basename(line.filtered_file)) %>:<%= line.filtered_number %> in <%= line.filtered_method %>
+<% else %>
+<%= i.zero? ? '>>>' : '   ' %> <%= line.unparsed_line %>
+<% end %>
+<% end %>

data/app/views/solid_errors/errors/_actions.html.erb

@@ -5,6 +5,15 @@
     </svg>
     <span>Back to errors</span>
   <% end %>
+  <template id="error-markdown"><%= error.to_markdown %></template>
+  <button id="copy-markdown"
+          class="inline-flex items-center justify-center gap-2 font-medium cursor-pointer border rounded-lg py-3 px-5 bg-gray-100 text-initial border-gray-300 hover:ring-gray-200 hover:ring-8">
+    <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-clipboard" viewBox="0 0 16 16">
+      <path d="M4 1.5H3a2 2 0 0 0-2 2V14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V3.5a2 2 0 0 0-2-2h-1v1h1a1 1 0 0 1 1 1V14a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V3.5a1 1 0 0 1 1-1h1z"/>
+      <path d="M9.5 1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5h-3a.5.5 0 0 1-.5-.5v-1a.5.5 0 0 1 .5-.5zm-3-1A1.5 1.5 0 0 0 5 1.5v1A1.5 1.5 0 0 0 6.5 4h3A1.5 1.5 0 0 0 11 2.5v-1A1.5 1.5 0 0 0 9.5 0z"/>
+    </svg>
+    <span>Copy Markdown</span>
+  </button>
   <% if error.resolved? %>
     <%= render 'solid_errors/errors/delete_button', error: error %>
   <% else %>

data/app/views/solid_errors/occurrences/_backtrace_line.html.erb

@@ -0,0 +1,14 @@
+<%= tag.details open: open do %>
+  <summary class="hover:bg-gray-50 px-2 py-1 rounded cursor-pointer">
+    <% if line.filtered_file %>
+      <span class="text-gray-500"><%= File.dirname(line.filtered_file) %>/</span><span class="text-blue-500 font-medium"><%= File.basename(line.filtered_file) %></span>:<span class="text-gray-900 font-medium"><%= line.filtered_number %></span>
+      <span class="text-gray-500">in</span>
+      <code class="text-green-500 font-medium"><%= line.filtered_method %></code>
+    <% else %>
+      <span class="text-gray-500"><%= line.unparsed_line %></span>
+    <% end %>
+  </summary>
+  <div><pre class="flex overflow-auto rounded-b-lg bg-slate-800 p-4 text-sm leading-normal text-white sm:rounded-t-lg"><code class="flex flex-1 flex-col min-h-full min-w-content px-0"><% line.source.each do |n, code| %>
+      <div class="line <%= n == line.filtered_number.to_i ? 'bg-gray-600/50' : '' %>"><span class="mr-2 text-right select-none text-gray-600"><%= n %></span><span><%= code %></span></div>
+    <% end %></code></pre></div>
+<% end %>

data/app/views/solid_errors/occurrences/_occurrence.html.erb

@@ -25,22 +25,39 @@
             <%= SolidErrors::Occurrence.human_attribute_name(:backtrace) %>
           </dt>
           <dd class="">
-            <% backtrace.lines.each_with_index do |line, i| %>
-              <%= tag.details open: line.application? || i.zero? do %>
-                <summary class="hover:bg-gray-50 px-2 py-1 rounded cursor-pointer">
-                  <% if line.filtered_file %>
-                    <span class="text-gray-500"><%= File.dirname(line.filtered_file) %>/</span><span class="text-blue-500 font-medium"><%= File.basename(line.filtered_file) %></span>:<span class="text-gray-900 font-medium"><%= line.filtered_number %></span>
-                    <span class="text-gray-500">in</span>
-                    <code class="text-green-500 font-medium"><%= line.filtered_method %></code>
-                  <% else %>
-                    <span class="text-gray-500"><%= line.unparsed_line %></span>
-                  <% end %>
-                </summary>
-                <div><pre class="flex overflow-auto rounded-b-lg bg-slate-800 p-4 text-sm leading-normal text-white sm:rounded-t-lg"><code class="flex flex-1 flex-col min-h-full min-w-content px-0"><% line.source.each do |n, code| %>
-                    <div class="line <%= n == line.filtered_number.to_i ? 'bg-gray-600/50' : '' %>"><span class="mr-2 text-right select-none text-gray-600"><%= n %></span><span><%= code %></span></div>
-                  <% end %></code></pre></div>
+            <div class="flex gap-2 mb-3">
+              <button type="button"
+                      data-backtrace-toggle="application"
+                      data-occurrence-id="<%= occurrence.id %>"
+                      class="backtrace-toggle inline-flex items-center border-b-2 px-3 py-2 text-sm font-medium cursor-pointer border-blue-500 text-blue-500">
+                Application
+              </button>
+              <button type="button"
+                      data-backtrace-toggle="full"
+                      data-occurrence-id="<%= occurrence.id %>"
+                      class="backtrace-toggle inline-flex items-center border-b-2 px-3 py-2 text-sm font-medium cursor-pointer border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700">
+                Full
+              </button>
+            </div>
+
+            <div id="backtrace-application-<%= occurrence.id %>">
+              <% if backtrace.application_lines.empty? %>
+                <p class="text-gray-500 text-sm">
+                  <em>No application code in backtrace.</em>
+                  <button type="button" data-backtrace-toggle="full" data-occurrence-id="<%= occurrence.id %>" class="text-blue-500 hover:underline cursor-pointer">
+                    View full trace
+                  </button>
+                </p>
+              <% else %>
+                <%= render partial: "solid_errors/occurrences/backtrace_line", collection: backtrace.application_lines, as: :line, locals: {open: true} %>
+              <% end %>
+            </div>
+
+            <div id="backtrace-full-<%= occurrence.id %>" hidden>
+              <% backtrace.lines.each_with_index do |line, i| %>
+                <%= render "solid_errors/occurrences/backtrace_line", line: line, open: line.application? || i.zero? %>
               <% end %>
-            <% end %>
+            </div>
           </dd>
         </div>
       </dl>

data/lib/solid_errors/engine.rb

@@ -18,7 +18,7 @@ module SolidErrors
     end
 
     initializer "solid_errors.active_record.error_subscriber" do
-      Rails.error.subscribe(SolidErrors::Subscriber.new)
+      Rails.error.subscribe(SolidErrors::Subscriber.new) if SolidErrors.enabled
     end
   end
 end

data/lib/solid_errors/sanitizer.rb

@@ -49,6 +49,10 @@ module SolidErrors
       when String
         sanitize_string(data)
       else # all other objects
+        if (global_id = global_id(data))
+          return global_id
+        end
+
         klass = data.class
 
         begin
@@ -67,6 +71,15 @@ module SolidErrors
 
     attr_reader :max_depth
 
+    # A saved record is identified by its GlobalID (gid://app/User/1) instead of just its class
+    def global_id(object)
+      return unless object.respond_to?(:to_global_id)
+
+      object.to_global_id.to_s
+    rescue
+      nil
+    end
+
     def basic_object?(object)
       object.respond_to?(:to_s)
       false

data/lib/solid_errors/subscriber.rb

@@ -32,24 +32,47 @@ module SolidErrors
       }
       fingerprint = Digest::SHA256.hexdigest(error_attributes.values.join)
       if (record = SolidErrors::Error.find_by(fingerprint: fingerprint))
+        opens_error = :reopened if record.resolved?
         record.update!(resolved_at: nil, updated_at: Time.now)
       else
+        opens_error = :created
         record = SolidErrors::Error.create!(error_attributes.merge(fingerprint: fingerprint))
       end
 
       SolidErrors::Occurrence.create(
         error_id: record.id,
         backtrace: error.backtrace&.join("\n"),
-        context: s(context)
+        context: s(readable_context(context)),
+        opens_error: opens_error
       )
     end
 
+    # Rails puts the current controller or job in the context; keep what identifies the work, not the object
+    def readable_context(context)
+      context = context.dup
+      if defined?(ActionController::Metal) && (controller = context[:controller]).is_a?(ActionController::Metal)
+        context[:controller] = "#{controller.class.name}##{controller.action_name}"
+        context[:params] ||= controller.request.filtered_parameters.except("controller", "action")
+      end
+      if defined?(ActiveJob::Base) && (job = context[:job]).is_a?(ActiveJob::Base)
+        context[:job] = job.class.name
+        context[:job_id] ||= job.job_id
+        context[:queue] ||= job.queue_name
+        context[:arguments] ||= parameter_filter.filter(arguments: s(job.arguments))[:arguments]
+      end
+      context
+    end
+
+    def parameter_filter
+      ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+    end
+
     def s(data)
       Sanitizer.sanitize(data)
     end
 
     def ignore_by_class?(error_class_name)
-      IGNORED_ERRORS.any? do |ignored_class|
+      [*IGNORED_ERRORS, *SolidErrors.ignored_errors].any? do |ignored_class|
         ignored_class_name = ignored_class.respond_to?(:name) ? ignored_class.name : ignored_class
 
         ignored_class_name == error_class_name

data/lib/solid_errors/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidErrors
-  VERSION = "0.7.1"
+  VERSION = "0.9.0"
 end

data/lib/solid_errors.rb

@@ -6,15 +6,22 @@ require_relative "solid_errors/subscriber"
 require_relative "solid_errors/engine"
 
 module SolidErrors
+  mattr_accessor :enabled, default: true
   mattr_accessor :connects_to
   mattr_accessor :base_controller_class, default: "::ActionController::Base"
   mattr_writer :username
   mattr_writer :password
-  mattr_accessor :send_emails, default: false
-  mattr_accessor :email_from, default: "solid_errors@noreply.com"
-  mattr_accessor :email_to
-  mattr_accessor :email_subject_prefix
+  mattr_writer :send_emails, :email_from, :email_to, :email_subject_prefix, default: nil
+  mattr_accessor :email_every_occurrence, default: true
+  # Builds the error email's subject, before email_subject_prefix. reason is :created or :reopened when
+  # the occurrence opened its error, nil for any other occurrence, or the app's own reason when it sends the email itself
+  mattr_accessor :email_subject, default: ->(error:, occurrence:, reason:) {
+    subject = "#{error.severity_emoji} #{error.exception_class}"
+    (reason == :reopened) ? "#{subject} (reopened)" : subject
+  }
   mattr_accessor :destroy_after
+  mattr_accessor :ignored_errors, default: []
+  mattr_writer :url_helper_name, :url_options
 
   class << self
     # use method instead of attr_accessor to ensure
@@ -29,6 +36,34 @@ module SolidErrors
       @password ||= ENV["SOLIDERRORS_PASSWORD"] || @@password
     end
 
+    # Each email setting falls back to its SOLIDERRORS_* environment variable when not configured
+    def send_emails
+      @@send_emails.nil? ? ActiveModel::Type::Boolean.new.cast(ENV["SOLIDERRORS_SEND_EMAILS"]) || false : @@send_emails
+    end
+
+    def email_from
+      @@email_from || ENV["SOLIDERRORS_EMAIL_FROM"] || "solid_errors@noreply.com"
+    end
+
+    def email_to
+      @@email_to || ENV["SOLIDERRORS_EMAIL_TO"]
+    end
+
+    def email_subject_prefix
+      @@email_subject_prefix || ENV["SOLIDERRORS_EMAIL_SUBJECT_PREFIX"]
+    end
+
+    # Whether the errors database has every table and column this version reads and writes.
+    # Assert it in your test suite to catch a schema change you haven't applied yet.
+    def migrated?
+      {
+        SolidErrors::Error => %w[exception_class message severity source resolved_at fingerprint created_at updated_at],
+        SolidErrors::Occurrence => %w[error_id backtrace context created_at updated_at]
+      }.all? do |model, columns|
+        model.table_exists? && (columns - model.column_names).empty?
+      end
+    end
+
     def send_emails?
       send_emails && email_to.present? && !ActiveSupport::IsolatedExecutionState[:solid_errors_without_emails]
     end
@@ -41,5 +76,30 @@ module SolidErrors
     ensure
       ActiveSupport::IsolatedExecutionState[:solid_errors_without_emails] = previous
     end
+
+    def url_helper_name
+      @@url_helper_name ||= detect_url_helper_name
+    end
+
+    def url_options
+      @@url_options ||= detect_url_options
+    end
+
+    private
+
+    def find_solid_errors_route
+      @solid_errors_route ||= Rails.application.routes.routes.find do |r|
+        r.name&.to_s&.end_with?("solid_errors")
+      end
+    end
+
+    def detect_url_helper_name
+      find_solid_errors_route&.name&.to_sym || :solid_errors
+    end
+
+    def detect_url_options
+      subdomain = find_solid_errors_route&.constraints&.dig(:subdomain)
+      subdomain.is_a?(String) ? {subdomain: subdomain} : {}
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_errors
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Stephen Margheim
@@ -120,6 +120,7 @@ files:
 - app/views/solid_errors/errors/_row.html.erb
 - app/views/solid_errors/errors/index.html.erb
 - app/views/solid_errors/errors/show.html.erb
+- app/views/solid_errors/occurrences/_backtrace_line.html.erb
 - app/views/solid_errors/occurrences/_collection.html.erb
 - app/views/solid_errors/occurrences/_occurrence.html.erb
 - config/locales/en.yml