rails_error_dashboard 0.1.19 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6669208b7836af38629663689984679194531516952a81b6d512f3cdd22d3104
-  data.tar.gz: bd8e1ba61465fd5845d98459717c6fa5380b29428a284cf77cfa8262cb40bf16
+  metadata.gz: e25820931efde6d62173ac5455658d05799202e5a3b7bc745ee5368880079ef2
+  data.tar.gz: 9cfc00e8a78eb876d64a1908df201b05231d2ec1ff538c8bbda391198e7c1947
 SHA512:
-  metadata.gz: f8620948152b3457008b0f020f7d7608fcb5822390e30e205c790502d3860fd7fe2aa0797d8f9742f78f90f6720fac013b0d124d876c06ac410571202c69b961
-  data.tar.gz: a518ea6dbd9cac88f59050bbc5d419ec270daef0682b958f82020f06ec6de8b66dc3346a61bf79e27e10d95838ecb811e7c8976111c27c8926d0545bd4b61f52
+  metadata.gz: db9e01290004af02ae9a5b9f55039ddeec858f1761c9ec685be1e7a5ec91590f8ed4ca1b5a7c1a1b57babf1e6cfb1b394afcb70504175949c0c8480fc7cb47f3
+  data.tar.gz: 7c04e609a1b700c51d634f932f20ab1ed448603e9390141f5cd5ba78c86415fda2bb413ef457a73d290967da998407b7f51a3655f425b2833462472212dc97e5

data/lib/rails_error_dashboard/manual_error_reporter.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # ManualErrorReporter: Report errors manually from frontend, mobile apps, or custom sources
+  #
+  # This class provides a clean API for logging errors that don't originate from Ruby exceptions,
+  # such as JavaScript errors from the frontend, mobile app crashes, or manually constructed errors.
+  #
+  # @example Frontend JavaScript error
+  #   RailsErrorDashboard::ManualErrorReporter.report(
+  #     error_type: "TypeError",
+  #     message: "Cannot read property 'foo' of undefined",
+  #     backtrace: ["at handleClick (app.js:42)", "at onClick (button.js:15)"],
+  #     platform: "Web",
+  #     user_id: current_user&.id,
+  #     request_url: request.url,
+  #     user_agent: request.user_agent,
+  #     metadata: { component: "ShoppingCart", action: "checkout" }
+  #   )
+  #
+  # @example Mobile app crash
+  #   RailsErrorDashboard::ManualErrorReporter.report(
+  #     error_type: "NSException",
+  #     message: "Fatal crash in payment processing",
+  #     backtrace: stacktrace_array,
+  #     platform: "iOS",
+  #     app_version: "2.1.0",
+  #     user_id: user_id,
+  #     metadata: { device: "iPhone 14", os_version: "17.2" }
+  #   )
+  class ManualErrorReporter
+    # Report a manual error to the dashboard
+    #
+    # @param error_type [String] The error class/type (e.g., "TypeError", "NetworkError")
+    # @param message [String] The error message
+    # @param backtrace [Array<String>, String, nil] Stack trace as array of strings or newline-separated string
+    # @param platform [String, nil] Platform where error occurred ("Web", "iOS", "Android", "API")
+    # @param user_id [String, Integer, nil] ID of the user who experienced the error
+    # @param request_url [String, nil] URL where the error occurred
+    # @param user_agent [String, nil] User agent string
+    # @param ip_address [String, nil] IP address of the requester
+    # @param app_version [String, nil] Version of the app where error occurred
+    # @param metadata [Hash, nil] Additional custom metadata about the error
+    # @param occurred_at [Time, nil] When the error occurred (defaults to Time.current)
+    # @param severity [Symbol, nil] Severity level (:critical, :high, :medium, :low)
+    # @param source [String, nil] Source identifier (e.g., "frontend", "mobile_app")
+    #
+    # @return [ErrorLog, nil] The created error log record, or nil if filtered/ignored
+    #
+    # @example Basic usage
+    #   ManualErrorReporter.report(
+    #     error_type: "ValidationError",
+    #     message: "Email format is invalid",
+    #     platform: "Web"
+    #   )
+    #
+    # @example With full context
+    #   ManualErrorReporter.report(
+    #     error_type: "PaymentError",
+    #     message: "Credit card declined",
+    #     backtrace: ["checkout.js:123", "payment.js:45"],
+    #     platform: "Web",
+    #     user_id: current_user.id,
+    #     request_url: checkout_url,
+    #     user_agent: request.user_agent,
+    #     ip_address: request.remote_ip,
+    #     app_version: "1.2.3",
+    #     metadata: { card_type: "visa", amount: 99.99 },
+    #     severity: :high
+    #   )
+    def self.report(
+      error_type:,
+      message:,
+      backtrace: nil,
+      platform: nil,
+      user_id: nil,
+      request_url: nil,
+      user_agent: nil,
+      ip_address: nil,
+      app_version: nil,
+      metadata: nil,
+      occurred_at: nil,
+      severity: nil,
+      source: nil
+    )
+      # Create a synthetic exception object that quacks like a Ruby exception
+      synthetic_exception = SyntheticException.new(
+        error_type: error_type,
+        message: message,
+        backtrace: normalize_backtrace(backtrace)
+      )
+
+      # Build context hash for LogError
+      context = {
+        source: source || "manual",
+        user_id: user_id,
+        request_url: request_url,
+        user_agent: user_agent,
+        ip_address: ip_address,
+        platform: platform,
+        app_version: app_version,
+        metadata: metadata,
+        occurred_at: occurred_at || Time.current,
+        severity: severity
+      }.compact # Remove nil values
+
+      # Use the existing LogError command
+      Commands::LogError.call(synthetic_exception, context)
+    end
+
+    # Normalize backtrace to array of strings
+    # @param backtrace [Array<String>, String, nil]
+    # @return [Array<String>]
+    private_class_method def self.normalize_backtrace(backtrace)
+      return [] if backtrace.nil?
+      return backtrace if backtrace.is_a?(Array)
+      return backtrace.split("\n") if backtrace.is_a?(String)
+      []
+    end
+
+    # SyntheticException: A fake exception object for manual error reporting
+    #
+    # This class mimics a Ruby Exception to work with the existing LogError command,
+    # but represents errors from non-Ruby sources (frontend, mobile, etc.)
+    #
+    # @api private
+    class SyntheticException
+      attr_reader :message, :backtrace
+
+      # @param error_type [String] The error class name
+      # @param message [String] The error message
+      # @param backtrace [Array<String>] The stack trace
+      def initialize(error_type:, message:, backtrace:)
+        @error_type = error_type
+        @message = message
+        @backtrace = backtrace
+      end
+
+      # Returns a mock class object that represents the error type
+      # @return [Object] A class-like object with the error type as its name
+      def class
+        # Return a simple object that quacks like a class
+        # This allows the error type to be stored correctly in the database
+        @class ||= MockClass.new(@error_type)
+      end
+
+      # MockClass: A simple class-like object for error typing
+      # @api private
+      class MockClass
+        def initialize(error_type)
+          @error_type = error_type
+        end
+
+        def name
+          @error_type
+        end
+
+        def to_s
+          @error_type
+        end
+      end
+
+      # Check if this is a specific error type
+      # @param klass [Class, String] The class to check against
+      # @return [Boolean]
+      def is_a?(klass)
+        return true if klass == self.class
+        return true if klass == SyntheticException
+        return true if klass.to_s == @error_type
+        false
+      end
+
+      # Inspect for debugging
+      # @return [String]
+      def inspect
+        "#<#{@error_type}: #{@message}>"
+      end
+    end
+
+    # Namespace for dynamically created manual error classes
+    # This keeps them separate from real Ruby exceptions
+    module ManualErrors
+    end
+  end
+end

data/lib/rails_error_dashboard/value_objects/error_context.rb

@@ -121,6 +121,9 @@ module RailsErrorDashboard
       end
 
       def detect_platform
+        # If platform is explicitly provided in context, use it
+        return @context[:platform] if @context[:platform].present?
+
         # Check if it's from a mobile request
         user_agent = extract_user_agent
 

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.19"
+  VERSION = "0.1.20"
 end

data/lib/rails_error_dashboard.rb

@@ -2,6 +2,7 @@ require "rails_error_dashboard/version"
 require "rails_error_dashboard/engine"
 require "rails_error_dashboard/configuration"
 require "rails_error_dashboard/logger"
+require "rails_error_dashboard/manual_error_reporter"
 
 # External dependencies
 require "pagy"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.20
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -342,6 +342,7 @@ files:
 - lib/rails_error_dashboard/engine.rb
 - lib/rails_error_dashboard/error_reporter.rb
 - lib/rails_error_dashboard/logger.rb
+- lib/rails_error_dashboard/manual_error_reporter.rb
 - lib/rails_error_dashboard/middleware/error_catcher.rb
 - lib/rails_error_dashboard/middleware/rate_limiter.rb
 - lib/rails_error_dashboard/plugin.rb
@@ -379,7 +380,7 @@ metadata:
   source_code_uri: https://github.com/AnjanJ/rails_error_dashboard
   changelog_uri: https://github.com/AnjanJ/rails_error_dashboard/blob/main/CHANGELOG.md
 post_install_message: "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n
-  \ Rails Error Dashboard v0.1.19\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
+  \ Rails Error Dashboard v0.1.20\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