rails_error_dashboard 0.1.37 → 0.2.0

data/lib/rails_error_dashboard/services/sensitive_data_filter.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Filter sensitive data from error attributes before storage
+    #
+    # On by default. Redacts passwords, tokens, credit cards, SSNs, etc. using
+    # built-in defaults + Rails' filter_parameters + custom patterns.
+    # Set filter_sensitive_data = false to store raw data (you own your database).
+    class SensitiveDataFilter
+      FILTERED_REPLACEMENT = "[FILTERED]"
+
+      # Default patterns that ALWAYS apply when filtering is enabled.
+      # These cover data that has no debugging value and should never be stored.
+      DEFAULT_SENSITIVE_PATTERNS = [
+        # Passwords
+        :password, :password_confirmation, :passphrase, :passwd,
+        # API keys & tokens
+        :token, :access_token, :refresh_token, :auth_token, :api_token,
+        :api_key, :api_secret, :secret, :secret_key, :private_key,
+        # Financial
+        :credit_card, :card_number, :cc_number, :cvv, :cvc, :csv,
+        # Personal identifiers
+        :ssn, :social_security,
+        # Session & auth
+        :session_id, :session_key, :cookie,
+        # 2FA / OTP
+        :otp, :totp, :pin
+      ].freeze
+
+      # Regex to detect credit card numbers in free text (4 groups of 4 digits)
+      CREDIT_CARD_REGEX = /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/
+
+      # Filter sensitive data from error attributes hash
+      # @param attributes [Hash] Error attributes to filter
+      # @return [Hash] Filtered attributes (or original if filtering disabled/fails)
+      def self.filter_attributes(attributes)
+        return attributes unless RailsErrorDashboard.configuration.filter_sensitive_data
+
+        filter = parameter_filter
+        return attributes unless filter
+
+        filtered = attributes.dup
+        filtered[:request_params] = filter_json_string(filter, filtered[:request_params])
+        filtered[:request_url] = filter_url(filter, filtered[:request_url])
+        filtered[:message] = filter_message(filter, filtered[:message])
+        filtered[:exception_cause] = filter_cause_chain(filter, filtered[:exception_cause])
+        filtered
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] SensitiveDataFilter failed: #{e.message}")
+        attributes
+      end
+
+      # Build and cache the ParameterFilter instance
+      # @return [ActiveSupport::ParameterFilter, nil]
+      def self.parameter_filter
+        @parameter_filter ||= build_parameter_filter
+      end
+
+      # Clear cached filter (for testing or config changes)
+      def self.reset!
+        @parameter_filter = nil
+      end
+
+      # Filter a JSON string by parsing, filtering the hash, and re-serializing
+      # @param filter [ActiveSupport::ParameterFilter] The filter instance
+      # @param json_string [String, nil] JSON string to filter
+      # @return [String, nil] Filtered JSON string
+      def self.filter_json_string(filter, json_string)
+        return json_string if json_string.nil? || json_string.empty?
+
+        parsed = JSON.parse(json_string)
+        filtered = filter.filter(parsed)
+        filtered.to_json
+      rescue JSON::ParserError
+        json_string
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] filter_json_string failed: #{e.message}")
+        json_string
+      end
+      private_class_method :filter_json_string
+
+      # Filter query string parameters in a URL
+      # @param filter [ActiveSupport::ParameterFilter] The filter instance
+      # @param url [String, nil] URL to filter
+      # @return [String, nil] URL with filtered query parameters
+      def self.filter_url(filter, url)
+        return url if url.nil? || !url.include?("?")
+
+        path, query = url.split("?", 2)
+        return url if query.nil? || query.empty?
+
+        params = Rack::Utils.parse_query(query)
+        filtered_params = filter.filter(params)
+        filtered_query = Rack::Utils.build_query(filtered_params)
+        "#{path}?#{filtered_query}"
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] filter_url failed: #{e.message}")
+        url
+      end
+      private_class_method :filter_url
+
+      # Filter key=value patterns in a message string
+      # @param filter [ActiveSupport::ParameterFilter] The filter instance
+      # @param message [String, nil] Message to filter
+      # @return [String, nil] Message with filtered values
+      def self.filter_message(filter, message)
+        return message if message.nil? || message.empty?
+
+        # Extract key=value patterns and filter them
+        result = message.gsub(/(\w+)=(\S+)/) do |_match|
+          key = Regexp.last_match(1)
+          value = Regexp.last_match(2)
+          filtered = filter.filter(key => value)
+          "#{key}=#{filtered[key]}"
+        end
+
+        # Scrub credit card numbers from free text
+        result.gsub(CREDIT_CARD_REGEX, FILTERED_REPLACEMENT)
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] filter_message failed: #{e.message}")
+        message
+      end
+      private_class_method :filter_message
+
+      # Filter messages within a cause chain JSON string
+      # @param filter [ActiveSupport::ParameterFilter] The filter instance
+      # @param cause_json [String, nil] JSON cause chain to filter
+      # @return [String, nil] Filtered cause chain JSON
+      def self.filter_cause_chain(filter, cause_json)
+        return cause_json if cause_json.nil? || cause_json.empty?
+
+        chain = JSON.parse(cause_json)
+        return cause_json unless chain.is_a?(Array)
+
+        filtered_chain = chain.map do |cause|
+          cause = cause.dup
+          cause["message"] = filter_message(filter, cause["message"]) if cause["message"]
+          cause
+        end
+
+        filtered_chain.to_json
+      rescue JSON::ParserError
+        cause_json
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] filter_cause_chain failed: #{e.message}")
+        cause_json
+      end
+      private_class_method :filter_cause_chain
+
+      # Build an ActiveSupport::ParameterFilter from Rails config + custom patterns
+      # @return [ActiveSupport::ParameterFilter, nil]
+      def self.build_parameter_filter
+        # Always start with default patterns (passwords, tokens, credit cards, etc.)
+        patterns = DEFAULT_SENSITIVE_PATTERNS.dup
+
+        # Rails' built-in filter_parameters
+        if defined?(Rails) && Rails.application&.config&.respond_to?(:filter_parameters)
+          patterns.concat(Array(Rails.application.config.filter_parameters))
+        end
+
+        # Custom patterns from gem config
+        custom = RailsErrorDashboard.configuration.sensitive_data_patterns
+        patterns.concat(Array(custom)) if custom
+
+        patterns.uniq!
+
+        ActiveSupport::ParameterFilter.new(patterns)
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] build_parameter_filter failed: #{e.message}")
+        nil
+      end
+      private_class_method :build_parameter_filter
+    end
+  end
+end

data/lib/rails_error_dashboard/value_objects/error_context.rb

@@ -6,7 +6,8 @@ module RailsErrorDashboard
     # Extracts and normalizes context information from various sources
     class ErrorContext
       attr_reader :user_id, :request_url, :request_params, :user_agent, :ip_address, :platform,
-                  :controller_name, :action_name, :request_id, :session_id
+                  :controller_name, :action_name, :request_id, :session_id,
+                  :http_method, :hostname, :content_type, :request_duration_ms
 
       def initialize(context, source = nil)
         @context = context
@@ -22,6 +23,10 @@ module RailsErrorDashboard
         @action_name = extract_action_name
         @request_id = extract_request_id
         @session_id = extract_session_id
+        @http_method = extract_http_method
+        @hostname = extract_hostname
+        @content_type = extract_content_type
+        @request_duration_ms = extract_request_duration_ms
       end
 
       def to_h
@@ -33,7 +38,11 @@ module RailsErrorDashboard
           ip_address: ip_address,
           platform: platform,
           controller_name: controller_name,
-          action_name: action_name
+          action_name: action_name,
+          http_method: http_method,
+          hostname: hostname,
+          content_type: content_type,
+          request_duration_ms: request_duration_ms
         }
       end
 
@@ -42,7 +51,8 @@ module RailsErrorDashboard
       def extract_user_id
         @context[:current_user]&.id ||
           @context[:user_id] ||
-          @context[:user]&.id
+          @context[:user]&.id ||
+          current_attributes_user_id
       end
 
       def build_request_url
@@ -176,7 +186,8 @@ module RailsErrorDashboard
         return @context[:job]&.job_id if @context[:job]
         return @context[:jid] if @context[:jid]
 
-        nil
+        # From CurrentAttributes (if app defines Current.request_id)
+        current_attributes_value(:request_id)
       end
 
       def extract_session_id
@@ -188,6 +199,72 @@ module RailsErrorDashboard
 
         nil
       end
+
+      def extract_http_method
+        return @context[:request]&.method if @context[:request]&.respond_to?(:method)
+        return @context[:http_method] if @context[:http_method]
+
+        nil
+      end
+
+      def extract_hostname
+        return @context[:request]&.host if @context[:request]&.respond_to?(:host)
+        return @context[:hostname] if @context[:hostname]
+
+        nil
+      end
+
+      def extract_content_type
+        if @context[:request]&.respond_to?(:content_type)
+          ct = @context[:request].content_type
+          # content_type can return a MIME::Type object or string depending on Rails version
+          return ct.to_s.presence
+        end
+
+        return @context[:content_type] if @context[:content_type]
+
+        nil
+      end
+
+      def extract_request_duration_ms
+        # Duration is calculated from the start time stored in the Rack env
+        if @context[:request]&.respond_to?(:env)
+          start_time = @context[:request].env["rails_error_dashboard.request_start"]
+          if start_time
+            elapsed = (Time.now.to_f - start_time.to_f) * 1000
+            return elapsed.round
+          end
+        end
+
+        return @context[:request_duration_ms] if @context[:request_duration_ms]
+
+        nil
+      end
+
+      # Auto-detect user_id from ActiveSupport::CurrentAttributes
+      # Checks for common patterns: Current.user, Current.account (with .id)
+      # Returns nil if CurrentAttributes is not used or user is not set
+      def current_attributes_user_id
+        return nil unless defined?(::Current)
+        return ::Current.user.id if ::Current.respond_to?(:user) && ::Current.user.respond_to?(:id)
+
+        nil
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] CurrentAttributes user_id detection failed: #{e.message}")
+        nil
+      end
+
+      # Read a single attribute from CurrentAttributes
+      # Returns nil if not available
+      def current_attributes_value(attribute_name)
+        return nil unless defined?(::Current)
+        return ::Current.public_send(attribute_name) if ::Current.respond_to?(attribute_name)
+
+        nil
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] CurrentAttributes #{attribute_name} detection failed: #{e.message}")
+        nil
+      end
     end
   end
 end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.37"
+  VERSION = "0.2.0"
 end

data/lib/rails_error_dashboard.rb

@@ -5,14 +5,15 @@ require "rails_error_dashboard/configuration"
 require "rails_error_dashboard/logger"
 require "rails_error_dashboard/manual_error_reporter"
 
-# External dependencies
+# Required dependencies
 require "pagy"
-require "pagy/extras/bootstrap"
-require "browser"
 require "groupdate"
-require "httparty"
-require "chartkick"
-require "turbo-rails"
+
+# Optional dependencies — features degrade gracefully without these
+begin; require "browser"; rescue LoadError; end
+begin; require "httparty"; rescue LoadError; end
+begin; require "chartkick"; rescue LoadError; end
+begin; require "turbo-rails"; rescue LoadError; end
 
 
 # Core library files
@@ -45,6 +46,10 @@ require "rails_error_dashboard/services/statistical_classifier"
 require "rails_error_dashboard/services/source_code_reader"
 require "rails_error_dashboard/services/git_blame_reader"
 require "rails_error_dashboard/services/github_link_generator"
+require "rails_error_dashboard/services/cause_chain_extractor"
+require "rails_error_dashboard/services/environment_snapshot"
+require "rails_error_dashboard/services/sensitive_data_filter"
+require "rails_error_dashboard/services/notification_throttler"
 require "rails_error_dashboard/queries/co_occurring_errors"
 require "rails_error_dashboard/queries/error_cascades"
 require "rails_error_dashboard/queries/baseline_stats"

data/lib/tasks/error_dashboard.rake

@@ -1,6 +1,162 @@
 # frozen_string_literal: true
 
 namespace :error_dashboard do
+  desc "Verify Rails Error Dashboard setup (database, tables, configuration)"
+  task verify: :environment do
+    puts "\n" + "=" * 70
+    puts "  RAILS ERROR DASHBOARD - SETUP VERIFICATION"
+    puts "=" * 70
+
+    checks_passed = 0
+    checks_failed = 0
+    warnings = 0
+
+    # 1. Configuration check
+    print "\n  Checking configuration... "
+    config = RailsErrorDashboard.configuration
+    begin
+      config.validate!
+      puts "OK"
+      checks_passed += 1
+    rescue RailsErrorDashboard::ConfigurationError => e
+      puts "FAILED"
+      puts "    Error: #{e.message}"
+      checks_failed += 1
+    end
+
+    # 2. Database mode
+    print "  Database mode... "
+    if config.use_separate_database
+      db_name = config.database || :error_dashboard
+      puts "SEPARATE (key: #{db_name})"
+    else
+      puts "SHARED (using primary database)"
+    end
+    checks_passed += 1
+
+    # 3. Database connection
+    print "  Database connection... "
+    begin
+      RailsErrorDashboard::ErrorLogsRecord.connection.active?
+      adapter = RailsErrorDashboard::ErrorLogsRecord.connection.adapter_name
+      puts "OK (#{adapter})"
+      checks_passed += 1
+    rescue => e
+      puts "FAILED"
+      puts "    Error: #{e.message}"
+      if config.use_separate_database
+        db_name = config.database || :error_dashboard
+        puts "    Hint: Make sure '#{db_name}:' is configured in config/database.yml"
+        puts "    Hint: Run 'rails db:create:#{db_name}' to create the database"
+      end
+      checks_failed += 1
+    end
+
+    # 4. Tables check
+    print "  Required tables... "
+    required_tables = %w[
+      rails_error_dashboard_applications
+      rails_error_dashboard_error_logs
+      rails_error_dashboard_error_occurrences
+      rails_error_dashboard_error_comments
+      rails_error_dashboard_error_baselines
+      rails_error_dashboard_cascade_patterns
+    ]
+
+    begin
+      conn = RailsErrorDashboard::ErrorLogsRecord.connection
+      existing = required_tables.select { |t| conn.table_exists?(t) }
+      missing = required_tables - existing
+
+      if missing.empty?
+        puts "OK (#{existing.size} tables found)"
+        checks_passed += 1
+      else
+        puts "INCOMPLETE"
+        missing.each { |t| puts "    Missing: #{t}" }
+        if config.use_separate_database
+          db_name = config.database || :error_dashboard
+          puts "    Hint: Run 'rails db:migrate:#{db_name}'"
+        else
+          puts "    Hint: Run 'rails db:migrate'"
+        end
+        checks_failed += 1
+      end
+    rescue => e
+      puts "SKIPPED (no connection)"
+    end
+
+    # 5. Application registration
+    print "  Application registration... "
+    begin
+      app_name = config.application_name ||
+                 ENV["APPLICATION_NAME"] ||
+                 (defined?(Rails) && Rails.application.class.module_parent_name) ||
+                 "Unknown"
+
+      current_app = RailsErrorDashboard::Application.find_by(name: app_name)
+      if current_app
+        puts "OK"
+        puts "    This app: \"#{app_name}\" (ID: #{current_app.id})"
+        checks_passed += 1
+      else
+        puts "PENDING"
+        puts "    App \"#{app_name}\" will be registered on first error"
+        warnings += 1
+      end
+
+      # List other registered apps
+      all_apps = RailsErrorDashboard::Application.order(:name).pluck(:name, :id)
+      other_apps = all_apps.reject { |name, _| name == app_name }
+      if other_apps.any?
+        puts "    Other apps in this database:"
+        other_apps.each { |name, id| puts "      - \"#{name}\" (ID: #{id})" }
+      end
+    rescue => e
+      puts "SKIPPED (#{e.message.truncate(60)})"
+    end
+
+    # 6. Error count
+    print "  Error data... "
+    begin
+      total = RailsErrorDashboard::ErrorLog.count
+      unresolved = RailsErrorDashboard::ErrorLog.where(resolved: false).count
+      puts "#{total} total errors (#{unresolved} unresolved)"
+      checks_passed += 1
+    rescue => e
+      puts "SKIPPED (#{e.message.truncate(60)})"
+    end
+
+    # 7. Authentication check
+    print "  Authentication... "
+    if config.dashboard_username == "gandalf" && config.dashboard_password == "youshallnotpass"
+      if Rails.env.production?
+        puts "WARNING - using default credentials in production!"
+        checks_failed += 1
+      else
+        puts "OK (default credentials - change before production)"
+        warnings += 1
+      end
+    else
+      puts "OK (custom credentials)"
+      checks_passed += 1
+    end
+
+    # Summary
+    puts "\n" + "-" * 70
+    puts "  Results: #{checks_passed} passed, #{checks_failed} failed, #{warnings} warnings"
+
+    if checks_failed > 0
+      puts "  Status: NEEDS ATTENTION"
+    elsif warnings > 0
+      puts "  Status: OK (with warnings)"
+    else
+      puts "  Status: ALL GOOD"
+    end
+
+    puts "=" * 70 + "\n"
+  end
+
   desc "List all registered applications with error counts"
   task list_applications: :environment do
     puts "\n" + "=" * 80
@@ -24,7 +180,7 @@ namespace :error_dashboard do
       next
     end
 
-    puts "\n#{apps.count} application(s) registered:\n\n"
+    puts "\n#{apps.length} application(s) registered:\n\n"
 
     # Calculate column widths using aggregated data (no additional queries)
     name_width = [ apps.map(&:name).map(&:length).max, 20 ].max
@@ -52,7 +208,7 @@ namespace :error_dashboard do
     total_unresolved = apps.sum(&:unresolved_errors)
 
     puts "\nSUMMARY:"
-    puts "  Total Applications: #{apps.count}"
+    puts "  Total Applications: #{apps.length}"
     puts "  Total Errors: #{total_errors}"
     puts "  Total Unresolved: #{total_unresolved}"
     puts "  Resolution Rate: #{total_errors.zero? ? 'N/A' : "#{((total_errors - total_unresolved).to_f / total_errors * 100).round(1)}%"}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.1.37
+  version: 0.2.0
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -29,28 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '43.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
-- !ruby/object:Gem::Dependency
-  name: browser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '43.0'
 - !ruby/object:Gem::Dependency
   name: groupdate
   requirement: !ruby/object:Gem::Requirement
@@ -65,48 +51,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
-- !ruby/object:Gem::Dependency
-  name: chartkick
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: httparty
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.24.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.24.0
-- !ruby/object:Gem::Dependency
-  name: turbo-rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -308,6 +252,7 @@ files:
 - app/jobs/rails_error_dashboard/discord_error_notification_job.rb
 - app/jobs/rails_error_dashboard/email_error_notification_job.rb
 - app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb
+- app/jobs/rails_error_dashboard/retention_cleanup_job.rb
 - app/jobs/rails_error_dashboard/slack_error_notification_job.rb
 - app/jobs/rails_error_dashboard/webhook_error_notification_job.rb
 - app/mailers/rails_error_dashboard/application_mailer.rb
@@ -357,6 +302,11 @@ files:
 - db/migrate/20260106094233_add_application_to_error_logs.rb
 - db/migrate/20260106094256_backfill_application_for_existing_errors.rb
 - db/migrate/20260106094318_finalize_application_foreign_key.rb
+- db/migrate/20260220000001_add_exception_cause_to_error_logs.rb
+- db/migrate/20260220000002_add_enriched_context_to_error_logs.rb
+- db/migrate/20260220000003_add_time_series_indexes_to_error_logs.rb
+- db/migrate/20260221000001_add_environment_info_to_error_logs.rb
+- db/migrate/20260221000002_add_reopened_at_to_error_logs.rb
 - lib/generators/rails_error_dashboard/install/install_generator.rb
 - lib/generators/rails_error_dashboard/install/templates/README
 - lib/generators/rails_error_dashboard/install/templates/initializer.rb
@@ -415,7 +365,9 @@ files:
 - lib/rails_error_dashboard/services/baseline_alert_throttler.rb
 - lib/rails_error_dashboard/services/baseline_calculator.rb
 - lib/rails_error_dashboard/services/cascade_detector.rb
+- lib/rails_error_dashboard/services/cause_chain_extractor.rb
 - lib/rails_error_dashboard/services/discord_payload_builder.rb
+- lib/rails_error_dashboard/services/environment_snapshot.rb
 - lib/rails_error_dashboard/services/error_broadcaster.rb
 - lib/rails_error_dashboard/services/error_hash_generator.rb
 - lib/rails_error_dashboard/services/error_normalizer.rb
@@ -424,11 +376,13 @@ files:
 - lib/rails_error_dashboard/services/git_blame_reader.rb
 - lib/rails_error_dashboard/services/github_link_generator.rb
 - lib/rails_error_dashboard/services/notification_helpers.rb
+- lib/rails_error_dashboard/services/notification_throttler.rb
 - lib/rails_error_dashboard/services/pagerduty_payload_builder.rb
 - lib/rails_error_dashboard/services/pattern_detector.rb
 - lib/rails_error_dashboard/services/pearson_correlation.rb
 - lib/rails_error_dashboard/services/platform_detector.rb
 - lib/rails_error_dashboard/services/priority_score_calculator.rb
+- lib/rails_error_dashboard/services/sensitive_data_filter.rb
 - lib/rails_error_dashboard/services/severity_classifier.rb
 - lib/rails_error_dashboard/services/similarity_calculator.rb
 - lib/rails_error_dashboard/services/slack_payload_builder.rb
@@ -449,7 +403,7 @@ metadata:
   documentation_uri: https://AnjanJ.github.io/rails_error_dashboard
   bug_tracker_uri: https://github.com/AnjanJ/rails_error_dashboard/issues
 post_install_message: "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n
-  \ Rails Error Dashboard v0.1.37\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
+  \ Rails Error Dashboard v0.2.0\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
   First time? Quick start:\n   rails generate rails_error_dashboard:install\n   rails
   db:migrate\n   # Add to config/routes.rb:\n   mount RailsErrorDashboard::Engine
   => '/error_dashboard'\n\n\U0001F504 Upgrading from v0.1.x?\n   rails db:migrate\n