rails_error_dashboard 0.14.4 → 0.16.0

data/lib/rails_error_dashboard/configuration.rb

@@ -13,7 +13,8 @@ module RailsErrorDashboard
     # #inspect) or pasting it into an issue doesn't leak them.
     SECRET_ATTRIBUTES = %i[
       dashboard_password slack_webhook_url discord_webhook_url pagerduty_integration_key
-      webhook_urls issue_tracker_token issue_webhook_secret llm_api_key
+      webhook_urls webhook_signing_secret issue_tracker_token issue_webhook_secret llm_api_key
+      telegram_bot_token
     ].freeze
 
     # Dashboard authentication (always required)
@@ -46,6 +47,14 @@ module RailsErrorDashboard
     attr_accessor :discord_webhook_url
     attr_accessor :enable_discord_notifications
 
+    # Telegram (Bot API: a bot token from @BotFather and the chat, group or
+    # channel the bot posts to). telegram_api_base_url exists for a local Bot
+    # API server or a proxy; nearly every install leaves it alone.
+    attr_accessor :enable_telegram_notifications
+    attr_accessor :telegram_bot_token
+    attr_accessor :telegram_chat_id
+    attr_accessor :telegram_api_base_url
+
     # PagerDuty notifications (critical errors only)
     attr_accessor :pagerduty_integration_key
     attr_accessor :enable_pagerduty_notifications
@@ -53,6 +62,9 @@ module RailsErrorDashboard
     # Generic webhook notifications
     attr_accessor :webhook_urls
     attr_accessor :enable_webhook_notifications
+    # When set, every POST to webhook_urls carries an HMAC-SHA256 signature
+    # (X-Error-Dashboard-Signature-256) and a timestamp the receiver can verify.
+    attr_accessor :webhook_signing_secret
 
     # Scheduled digests (daily/weekly summary emails)
     attr_accessor :enable_scheduled_digests         # Master switch (default: false)
@@ -206,6 +218,7 @@ module RailsErrorDashboard
     # Instance variable capture from tp.self (receiver object at raise time)
     attr_accessor :enable_instance_variables           # Master switch (default: false)
     attr_accessor :instance_variable_max_count          # Max ivars to capture (default: 20)
+    attr_accessor :occurrence_context_limit             # Occurrences per error whose context is kept (default: 25; 0 = off)
     attr_accessor :instance_variable_filter_patterns    # Additional sensitive ivar patterns (default: [])
 
     # Swallowed exception detection via TracePoint(:raise) + TracePoint(:rescue) (Ruby 3.3+ only)
@@ -231,6 +244,12 @@ module RailsErrorDashboard
     attr_accessor :rack_attack_max_cache_size           # Max buffered keys per thread (default: 1000)
     attr_accessor :rack_attack_flush_interval           # Seconds between DB flushes (default: 5)
 
+    # Missing-translation tracking — counts the HOST app's I18n misses by
+    # locale and key in their own table. Wraps I18n.exception_handler
+    # (delegating to the handler the app already had); the one place RED
+    # touches global I18n state, so it is opt-in.
+    attr_accessor :enable_missing_translation_tracking  # Master switch (default: false)
+
     # ActionCable event tracking (requires enable_breadcrumbs = true)
     attr_accessor :enable_actioncable_tracking          # Master switch (default: false)
     # ActiveStorage event tracking (requires enable_breadcrumbs = true)
@@ -309,6 +328,12 @@ module RailsErrorDashboard
       @discord_webhook_url = ENV["DISCORD_WEBHOOK_URL"]
       @enable_discord_notifications = false
 
+      # Telegram notification settings
+      @enable_telegram_notifications = false
+      @telegram_bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+      @telegram_chat_id = ENV["TELEGRAM_CHAT_ID"]
+      @telegram_api_base_url = ENV.fetch("TELEGRAM_API_BASE_URL", "https://api.telegram.org")
+
       # PagerDuty notification settings (critical errors only)
       @pagerduty_integration_key = ENV["PAGERDUTY_INTEGRATION_KEY"]
       @enable_pagerduty_notifications = false
@@ -316,6 +341,10 @@ module RailsErrorDashboard
       # Generic webhook settings (array of URLs)
       @webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
       @enable_webhook_notifications = false
+      # nil leaves outbound webhooks unsigned, as before. Secret-only (no
+      # separate "enable" flag): a secret with nothing to apply it to is the
+      # one combination that has no sensible meaning.
+      @webhook_signing_secret = ENV["WEBHOOK_SIGNING_SECRET"].presence
 
       # Scheduled digest defaults - OFF by default (opt-in)
       @enable_scheduled_digests = false
@@ -453,6 +482,9 @@ module RailsErrorDashboard
       # Instance variable capture defaults - OFF by default (opt-in)
       @enable_instance_variables = false         # Capture ivars from tp.self at raise time
       @instance_variable_max_count = 20          # Max ivars per exception
+      # Keep the moment-of-failure context of the newest 25 occurrences of each
+      # error, not only the latest. 0 keeps none.
+      @occurrence_context_limit = 25
       @instance_variable_filter_patterns = []    # Additional sensitive ivar name patterns
 
       # Swallowed exception detection defaults - OFF by default (Ruby 3.3+ opt-in)
@@ -483,6 +515,10 @@ module RailsErrorDashboard
       # roughly one write per thread per interval.
       @rack_attack_flush_interval = 5    # Seconds between DB flushes
 
+      # Missing-translation tracking - OFF by default (opt-in). Persists to its
+      # own table; does NOT require breadcrumbs.
+      @enable_missing_translation_tracking = false
+
       # ActionCable event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
       @enable_actioncable_tracking = false
       # ActiveStorage event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
@@ -642,6 +678,13 @@ module RailsErrorDashboard
         end
       end
 
+      # Any other git_branch_strategy links to main. A warning, not an error:
+      # a link format is not worth stopping a boot.
+      if git_branch_strategy && !%w[commit_sha current_branch main].include?(git_branch_strategy.to_s)
+        warnings << "git_branch_strategy must be one of :commit_sha, :current_branch or :main " \
+                    "(got: #{git_branch_strategy.inspect}). Repository links will point at main."
+      end
+
       # Validate custom_fingerprint (must respond to .call if set)
       if custom_fingerprint && !custom_fingerprint.respond_to?(:call)
         errors << "custom_fingerprint must respond to .call (lambda, proc, or object with .call method)"
@@ -680,6 +723,10 @@ module RailsErrorDashboard
         errors << "instance_variable_max_count must be at least 1 (got: #{instance_variable_max_count})"
       end
 
+      unless occurrence_context_limit.is_a?(Integer) && occurrence_context_limit >= 0
+        errors << "occurrence_context_limit must be a whole number of 0 or more (got: #{occurrence_context_limit.inspect})"
+      end
+
       # Validate swallowed exception detection settings
       # Auto-disable on Ruby < 3.3 (warn, don't crash)
       if detect_swallowed_exceptions && RUBY_VERSION < "3.3"
@@ -810,6 +857,15 @@ module RailsErrorDashboard
           errors << "discord_webhook_url is required when enable_discord_notifications is true"
         end
 
+        if enable_telegram_notifications
+          if telegram_bot_token.to_s.strip.empty?
+            errors << "telegram_bot_token is required when enable_telegram_notifications is true"
+          end
+          if telegram_chat_id.to_s.strip.empty?
+            errors << "telegram_chat_id is required when enable_telegram_notifications is true"
+          end
+        end
+
         if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
           errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
         end
@@ -1085,9 +1141,10 @@ module RailsErrorDashboard
       return nil if effective_issue_tracker_provider == :linear
       return nil if git_repository_url.blank?
 
-      # Extract owner/repo from URL: https://github.com/owner/repo(.git)
-      match = git_repository_url.match(%r{[:/]([^/]+/[^/]+?)(?:\.git)?$})
-      match&.[](1)
+      # owner/repo from the normalized URL, so ".git", ".git/" and trailing
+      # slashes all name the same repository the View Source links use
+      url = Services::RepositoryUrl.normalize(git_repository_url)
+      url.match(%r{[:/]([^/]+/[^/]+)\z})&.[](1)
     end
 
     # Resolve the issue tracker API token (supports string or lambda)

data/lib/rails_error_dashboard/engine.rb

@@ -48,6 +48,22 @@ module RailsErrorDashboard
       end
     end
 
+    # Register the crash-capture at_exit hook as soon as the host's
+    # config/initializers have run (so enable_crash_capture is known) and
+    # BEFORE Rails' :eager_load! finisher. Every engine initializer runs ahead
+    # of the finishers, so this is early enough for a Zeitwerk::NameError, a
+    # SyntaxError in a model or a raising initializer to be captured; the old
+    # place, config.after_initialize, runs AFTER eager loading and was never
+    # reached by exactly the crashes a boot check exists for. The import of
+    # earlier crash files stays in after_initialize, where the database is.
+    initializer "rails_error_dashboard.crash_capture", after: :load_config_initializers do
+      next if ENV["SECRET_KEY_BASE_DUMMY"].present?
+
+      if RailsErrorDashboard.configuration.enable_crash_capture
+        RailsErrorDashboard::Services::CrashCapture.enable!
+      end
+    end
+
     # Validate configuration after initialization
     initializer "rails_error_dashboard.validate_config", after: :load_config_initializers do
       config.after_initialize do
@@ -133,6 +149,28 @@ module RailsErrorDashboard
         at_exit { RailsErrorDashboard::Services::RackAttackTracker.flush_all_threads! }
       end
 
+      # Count the host app's missing translations. The handler wrap is the one
+      # place RED touches global I18n state, so it runs only when opted in,
+      # and here in after_initialize so the handler the host's own
+      # initializers configured is the one being wrapped (and delegated to).
+      #
+      # Same drain points as Rack Attack tracking: to_complete fires after the
+      # response body is closed (never delays a request, safety rule 2) and is
+      # interval-gated; at_exit drains whatever buffers are still on live
+      # threads. Puma joins its worker threads before at_exit runs, so what a
+      # worker held at SIGTERM (at most FLUSH_INTERVAL seconds of misses) is
+      # lost with it; the hook still covers the main thread, runners and
+      # console sessions. at_exit, not Signal.trap (safety rule 9).
+      if RailsErrorDashboard.configuration.enable_missing_translation_tracking
+        RailsErrorDashboard::Services::MissingTranslationHandler.install!
+
+        Rails.application.executor.to_complete do
+          RailsErrorDashboard::Services::MissingTranslationTracker.flush_if_due!
+        end
+
+        at_exit { RailsErrorDashboard::Services::MissingTranslationTracker.flush_all_threads! }
+      end
+
       # Drain the storm count buffer at the end of every request and job, and
       # again at process exit.
       #
@@ -224,7 +262,10 @@ module RailsErrorDashboard
         end
       end
 
-      # Import crash files from previous process death, then register at_exit hook
+      # Import crash files from a previous process death. The at_exit hook
+      # itself is registered by the "rails_error_dashboard.crash_capture"
+      # initializer above, before eager loading; enable! here is a no-op when
+      # that ran and a fallback when the configuration was only set later.
       if RailsErrorDashboard.configuration.enable_crash_capture
         RailsErrorDashboard::Services::CrashCapture.import!
         RailsErrorDashboard::Services::CrashCapture.enable!

data/lib/rails_error_dashboard/error_reporter.rb

@@ -46,8 +46,10 @@ module RailsErrorDashboard
         # Skip duplicate reports from our own middleware when the subscriber
         # already captured this error with full request context above.
         # Without this, async logging enqueues two jobs for one exception —
-        # and non-deterministic job ordering can overwrite good data.
-        if source == "rack.middleware" &&
+        # and non-deterministic job ordering can overwrite good data. The
+        # middleware's report also carries context[:middleware], because Rails
+        # 7.0's reporter passes subscribers no source.
+        if (source == "rack.middleware" || context[:middleware]) &&
            Thread.current[:rails_error_dashboard_reported_errors]&.include?(error.object_id)
           return
         end

data/lib/rails_error_dashboard/manual_error_reporter.rb

@@ -49,7 +49,12 @@ module RailsErrorDashboard
     #   believe they had set a value that was never read.
     # @param source [String, nil] Source identifier (e.g., "frontend", "mobile_app")
     #
-    # @return [ErrorLog, nil] The created error log record, or nil if filtered/ignored
+    # @return [ErrorLog, nil] The created or updated error log record. nil when
+    #   no row is written now, or none is returned:
+    #   - the error is ignored or sampled out (ignored_exceptions, sampling_rate)
+    #   - storm protection only counts it (:count_only)
+    #   - async_logging is on: a job writes the row later
+    #   - logging failed internally (RED never raises into your code)
     #
     # @example Basic usage
     #   ManualErrorReporter.report(
@@ -106,6 +111,11 @@ module RailsErrorDashboard
         occurred_at: occurred_at || Time.current
       }.compact # Remove nil values
 
+      # Marks this as a client report, so nothing reads this app's source files
+      # for its backtrace. Set here, after the caller's values, and from no
+      # argument: source: is only a label.
+      context[:_capture_source] = "client"
+
       # severity is deliberately NOT forwarded: nothing downstream reads it,
       # and passing it on would keep the illusion that it does.
       if severity.present?

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -38,15 +38,19 @@ module RailsErrorDashboard
         # Report to Rails.error (will be logged by our ErrorReporter)
         # CRITICAL: Wrap in rescue to ensure gem failures don't break the app
         begin
-          Rails.error.report(exception,
+          options = {
             handled: false,
             severity: :error,
             context: {
               request: ActionDispatch::Request.new(env),
               middleware: true
-            },
-            source: "rack.middleware"
-          )
+            }
+          }
+          # Rails 7.0's ErrorReporter#report takes no source: keyword (7.1
+          # added it). Passing one raised ArgumentError there, which the rescue
+          # below swallowed, so on 7.0 this middleware reported nothing.
+          options[:source] = "rack.middleware" if report_takes_source?
+          Rails.error.report(exception, **options)
         rescue => e
           # If error reporting fails, log it but DON'T break the app
           RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Middleware error reporting failed: #{e.class} - #{e.message}")
@@ -61,6 +65,16 @@ module RailsErrorDashboard
         Thread.current[:rails_error_dashboard_reported_errors] = nil
         RailsErrorDashboard::Services::BreadcrumbCollector.clear_buffer
       end
+
+      private
+
+      # Asked of the reporter's class, not the object: a stubbed or wrapped
+      # report method hides its real keywords.
+      def report_takes_source?
+        Rails.error.class.instance_method(:report).parameters.any? do |type, name|
+          name == :source || type == :keyrest
+        end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/middleware/rate_limiter.rb

@@ -55,8 +55,14 @@ module RailsErrorDashboard
         "/red"
       end
 
+      # The mount itself or anything below it. A plain start_with? also
+      # matched the host's own /redirect when the engine was at /red. An
+      # engine mounted at "/" owns every path.
       def error_dashboard_route?(path)
-        path.start_with?(engine_mount_path)
+        mount = engine_mount_path.to_s.chomp("/")
+        return true if mount.empty?
+
+        path == mount || path.start_with?("#{mount}/")
       end
 
       def rate_limit_key(request, limit_config)

data/lib/rails_error_dashboard/plugin.rb

@@ -121,11 +121,27 @@ module RailsErrorDashboard
 
       send(method_name, *args)
     rescue => e
-      # Log plugin failures but never propagate - plugins must not break the app
-      RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Plugin '#{name}' failed in #{method_name}: #{e.class} - #{e.message}")
-      RailsErrorDashboard::Logger.error("Plugin version: #{version}")
+      # Log plugin failures but never propagate - plugins must not break the app.
+      # name and version are plugin code too, so the log line must not depend
+      # on them answering.
+      RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Plugin '#{safe_label}' failed in #{method_name}: #{e.class} - #{e.message}")
+      RailsErrorDashboard::Logger.error("Plugin version: #{safe_version}")
       RailsErrorDashboard::Logger.error(e.backtrace&.first(10)&.join("\n")) if e.backtrace
       nil # Explicitly return nil, never raise
     end
+
+    private
+
+    def safe_label
+      name.to_s
+    rescue StandardError, NotImplementedError
+      self.class.name
+    end
+
+    def safe_version
+      version.to_s
+    rescue StandardError, NotImplementedError
+      "unknown"
+    end
   end
 end

data/lib/rails_error_dashboard/plugin_registry.rb

@@ -3,6 +3,13 @@
 module RailsErrorDashboard
   # Registry for managing plugins
   # Provides plugin registration and event dispatching
+  #
+  # A plugin is host code running inside RED's own paths, so nothing it does
+  # may break them: a `name` that raises (the base class raises
+  # NotImplementedError, a ScriptError that `rescue => e` does not catch), an
+  # `on_register` that raises, or an `enabled?` that raises is logged and
+  # treated as "no", never propagated. A plugin is in the list only once
+  # registration has fully succeeded.
   class PluginRegistry
     class << self
       # Get all registered plugins
@@ -12,26 +19,41 @@ module RailsErrorDashboard
 
       # Register a plugin
       # @param plugin [Plugin] The plugin instance to register
+      # @return [Boolean] true when registered, false when skipped
+      # @raise [ArgumentError] not a Plugin, or no usable name
       def register(plugin)
         unless plugin.is_a?(Plugin)
           raise ArgumentError, "Plugin must be an instance of RailsErrorDashboard::Plugin"
         end
 
-        if plugins.any? { |p| p.name == plugin.name }
-          RailsErrorDashboard::Logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
+        name = name_of(plugin)
+        if name.blank?
+          raise ArgumentError, "Plugin #{plugin.class} must implement #name and return a non-blank String"
+        end
+
+        if plugins.any? { |p| name_of(p) == name }
+          RailsErrorDashboard::Logger.warn("Plugin '#{name}' is already registered, skipping")
+          return false
+        end
+
+        begin
+          plugin.on_register
+        rescue => e
+          RailsErrorDashboard::Logger.error(
+            "[RailsErrorDashboard] Plugin '#{name}' failed in on_register: #{e.class} - #{e.message}; not registered"
+          )
           return false
         end
 
         plugins << plugin
-        plugin.on_register
-        RailsErrorDashboard::Logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
+        RailsErrorDashboard::Logger.info("Registered plugin: #{name} (#{version_of(plugin)})")
         true
       end
 
       # Unregister a plugin by name
       # @param plugin_name [String] The name of the plugin to unregister
       def unregister(plugin_name)
-        plugins.reject! { |p| p.name == plugin_name }
+        plugins.reject! { |p| name_of(p) == plugin_name }
       end
 
       # Clear all plugins (useful for testing)
@@ -43,7 +65,7 @@ module RailsErrorDashboard
       # @param plugin_name [String] The name of the plugin
       # @return [Plugin, nil] The plugin instance or nil if not found
       def find(plugin_name)
-        plugins.find { |p| p.name == plugin_name }
+        plugins.find { |p| name_of(p) == plugin_name }
       end
 
       # Dispatch an event to all registered plugins
@@ -51,7 +73,7 @@ module RailsErrorDashboard
       # @param args [Array] Arguments to pass to the event handler
       def dispatch(event_name, *args)
         plugins.each do |plugin|
-          next unless plugin.enabled?
+          next unless enabled?(plugin)
 
           plugin.safe_execute(event_name, *args)
         end
@@ -69,20 +91,47 @@ module RailsErrorDashboard
 
       # Get list of plugin names
       def names
-        plugins.map(&:name)
+        plugins.map { |p| name_of(p) }
       end
 
       # Get plugin information for debugging
       def info
         plugins.map do |plugin|
           {
-            name: plugin.name,
-            version: plugin.version,
-            description: plugin.description,
-            enabled: plugin.enabled?
+            name: name_of(plugin),
+            version: version_of(plugin),
+            description: (plugin.description rescue nil),
+            enabled: enabled?(plugin)
           }
         end
       end
+
+      private
+
+      # A plugin's name, or nil when #name is missing or raises.
+      def name_of(plugin)
+        value = plugin.name
+        value.is_a?(String) ? value : value&.to_s
+      rescue StandardError, NotImplementedError
+        nil
+      end
+
+      def version_of(plugin)
+        plugin.version.to_s
+      rescue StandardError, NotImplementedError
+        "unknown"
+      end
+
+      # enabled? is host code too. A raise is logged once per dispatch and
+      # read as disabled, so the other plugins still run.
+      def enabled?(plugin)
+        plugin.enabled? ? true : false
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] Plugin '#{name_of(plugin) || plugin.class}' failed in enabled?: #{e.class} - #{e.message}; treated as disabled"
+        )
+        false
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -29,8 +29,6 @@ module RailsErrorDashboard
             errors_by_hour: errors_by_hour,
             top_users: top_affected_users,
             resolution_rate: resolution_rate,
-            mobile_errors: mobile_errors_count,
-            api_errors: api_errors_count,
             pattern_insights: pattern_insights
           }
         end
@@ -270,16 +268,6 @@ module RailsErrorDashboard
         ((resolved_count.to_f / total_groups) * 100).round(1)
       end
 
-      def mobile_errors_count
-        Queries::EventVolume.in_window(base_scope.where(platform: [ "iOS", "Android" ]), @start_date)
-      end
-
-      def api_errors_count
-        Queries::EventVolume.in_window(
-          base_scope.where("platform IS NULL OR platform = ?", "API"), @start_date
-        )
-      end
-
       #  Pattern insights for top error types
       # Analyzes occurrence patterns and bursts for top 5 error types
       def pattern_insights

data/lib/rails_error_dashboard/queries/boot_errors.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: the crashes that happened while the process was still booting.
+    #
+    # A boot crash (a Zeitwerk::NameError from eager loading, a SyntaxError in
+    # a model, an initializer that raised) is imported by CrashCapture with
+    # platform "boot_crash" and the file and constant it names, when it names
+    # them, in environment_info.boot. One entry per error row, most recent
+    # first: the question is "what stopped the last deploy", not a frequency
+    # ranking.
+    class BootErrors
+      PLATFORM = "boot_crash"
+
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      # @return [Hash] entries: [{id:, error_type:, message:, file:, constant:,
+      #   count:, first_seen:, last_seen:, resolved:}], unresolved_count: Integer
+      def call
+        rows = base_query
+          .order(last_seen_at: :desc, id: :desc)
+          .pluck(:id, :error_type, :message, :environment_info, :occurrence_count,
+                 :first_seen_at, :last_seen_at, :resolved)
+
+        entries = rows.map do |id, error_type, message, env_info, count, first_seen, last_seen, resolved|
+          boot = boot_detail(env_info)
+          {
+            id: id,
+            error_type: error_type.to_s,
+            message: message.to_s,
+            file: boot["file"].presence,
+            constant: boot["constant"].presence,
+            count: [ count.to_i, 1 ].max,
+            first_seen: first_seen,
+            last_seen: last_seen,
+            resolved: resolved ? true : false
+          }
+        end
+
+        { entries: entries, unresolved_count: entries.count { |e| !e[:resolved] } }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] BootErrors query failed: #{e.class}: #{e.message}")
+        { entries: [], unresolved_count: 0 }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where(platform: PLATFORM).where("last_seen_at >= ?", @start_date)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      # environment_info is JSON text; the boot detail is optional and the
+      # column may hold anything an older row wrote, so every step is guarded.
+      def boot_detail(env_info)
+        return {} if env_info.blank?
+
+        parsed = env_info.is_a?(String) ? JSON.parse(env_info) : env_info
+        boot = parsed.is_a?(Hash) ? parsed["boot"] : nil
+        boot.is_a?(Hash) ? boot : {}
+      rescue JSON::ParserError, TypeError
+        {}
+      end
+    end
+  end
+end