dislogger 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b7ddd219546d4b47916d9e0cfd1303679ed1a3f4befa6675a7be486ada7de25
-  data.tar.gz: '001685aeefc4f82fd7a07f8a539ea9c737de5a1760eebdc0799660ea62c4087d'
+  metadata.gz: 40772178fe1446aaa2cc9bafcb10f11815e3416ad6a7b294dfbd69e9c153c338
+  data.tar.gz: e6e2d4e174ae770eff2b0be41cd9364a6f81606b393061379b168a23eb60fbf8
 SHA512:
-  metadata.gz: 40495b36577cce4bb00ea8ab38b74019b4792e2ca6452c1edd735f4042557403ab382bb70b08f94e4fb952b7e5240c1828057a5068f76aad4c1da5ba6be1fc41
-  data.tar.gz: 2d90483f3e1db1969355be2565384cde9f38f7048e5dd4f7573203a47bb814f3ba45bf11554bf9e0dd71c4751e0d7fcece7d547664afa8f2959bc98fbdba0eb9
+  metadata.gz: 8bd268340561e183ef3668cee56ea2ca964d4c2a9b70571a7d2a9b683e57199be8444191284ff1a358167002acccefd57d7abe607594c2adbcf08703c9afa484
+  data.tar.gz: bbfbeed87f691bfa3d1f7049a5873d16f938fbd5b019dc71f04eb4024e1be59fb3fe5b65e77de547560df35fb2adeb63f1fbe14934f0679172c0aa0b03a69497

data/lib/dislogger/configuration.rb

@@ -13,7 +13,7 @@ module Dislogger
       @discord_webhook_url = nil
       @bot_username = 'Error Logger'
       @backtrace_lines_limit = 5
-      @enabled_environments = %w[production staging development]
+      @enabled_environments = %w[production staging]
       @environment = nil
       @error_color_map = {
         500 => 15158332, # Red for server errors

data/lib/dislogger/error_handler.rb

@@ -7,16 +7,116 @@ module Dislogger
     extend ActiveSupport::Concern
 
     included do
-      rescue_from StandardError, with: :handle_internal_server_error
-      rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
-      rescue_from ActiveRecord::RecordInvalid, with: :handle_unprocessable_entity
-      rescue_from ActionController::ParameterMissing, with: :handle_unprocessable_entity
-      rescue_from Pundit::NotAuthorizedError, with: :handle_forbidden if defined?(Pundit)
-      rescue_from CanCan::AccessDenied, with: :handle_forbidden if defined?(CanCan)
+      if ancestors.include?(ActionController::API) || ancestors.include?(ActionController::Base)
+        # System and Runtime Errors
+        rescue_from Exception, with: :handle_exception
+        rescue_from StandardError, with: :handle_internal_server_error
+        rescue_from RuntimeError, with: :handle_runtime_error
+        rescue_from SystemStackError, with: :handle_stack_error
+        rescue_from NoMemoryError, with: :handle_memory_error
+        rescue_from SystemCallError, with: :handle_system_error
+        rescue_from SignalException, with: :handle_signal_error
+        rescue_from ScriptError, with: :handle_script_error
+
+        # Database Errors
+        rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
+        rescue_from ActiveRecord::RecordInvalid, with: :handle_unprocessable_entity
+        rescue_from ActiveRecord::RecordNotUnique, with: :handle_conflict
+        rescue_from ActiveRecord::ConnectionTimeoutError, with: :handle_timeout
+        rescue_from ActiveRecord::InvalidForeignKey, with: :handle_foreign_key_error
+        rescue_from ActiveRecord::ReadOnlyRecord, with: :handle_forbidden
+        rescue_from ActiveRecord::StaleObjectError, with: :handle_conflict
+
+        # Controller and Routing Errors
+        rescue_from ActionController::ParameterMissing, with: :handle_unprocessable_entity
+        rescue_from ActionController::InvalidAuthenticityToken, with: :handle_unauthorized
+        rescue_from ActionController::UnknownFormat, with: :handle_not_acceptable
+        rescue_from ActionController::UrlGenerationError, with: :handle_bad_request
+        rescue_from ActionController::RoutingError, with: :handle_not_found
+        rescue_from AbstractController::ActionNotFound, with: :handle_not_found
+
+        # Authorization Errors
+        rescue_from Pundit::NotAuthorizedError, with: :handle_forbidden if defined?(Pundit)
+        rescue_from CanCan::AccessDenied, with: :handle_forbidden if defined?(CanCan)
+
+        # Common Ruby Errors
+        rescue_from NameError, with: :handle_internal_server_error
+        rescue_from NoMethodError, with: :handle_internal_server_error
+        rescue_from ArgumentError, with: :handle_bad_request
+        rescue_from TypeError, with: :handle_internal_server_error
+        rescue_from LoadError, with: :handle_internal_server_error
+        rescue_from SyntaxError, with: :handle_internal_server_error
+        rescue_from Timeout::Error, with: :handle_timeout
+      end
     end
 
     private
 
+    def handle_exception(exception)
+      # Log detailed error information
+      Rails.logger.error("[Dislogger] Unexpected error caught: #{exception.class.name}")
+      Rails.logger.error("[Dislogger] Message: #{exception.message}")
+      Rails.logger.error("[Dislogger] Backtrace:\n#{exception.backtrace.join("\n")}") if exception.backtrace
+
+      notify_and_render_error(
+        message: "An unexpected error occurred: #{exception.class.name} - #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace,
+        details: {
+          error_class: exception.class.name,
+          message: exception.message
+        }
+      )
+    end
+
+    def handle_runtime_error(exception)
+      notify_and_render_error(
+        message: "Runtime error: #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace
+      )
+    end
+
+    def handle_stack_error(exception)
+      notify_and_render_error(
+        message: "Stack overflow error: #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace
+      )
+    end
+
+    def handle_memory_error(exception)
+      notify_and_render_error(
+        message: "Out of memory error: #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace
+      )
+    end
+
+    def handle_system_error(exception)
+      notify_and_render_error(
+        message: "System error: #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace
+      )
+    end
+
+    def handle_signal_error(exception)
+      notify_and_render_error(
+        message: "Signal error: #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace
+      )
+    end
+
+    def handle_script_error(exception)
+      notify_and_render_error(
+        message: "Script error: #{exception.message}",
+        status: :internal_server_error,
+        backtrace: exception.backtrace
+      )
+    end
+
     def handle_not_found(exception)
       notify_and_render_error(
         message: exception.message.presence || 'Resource not found',
@@ -25,7 +125,14 @@ module Dislogger
     end
 
     def handle_unprocessable_entity(exception)
-      errors = exception.respond_to?(:record) ? exception.record.errors.full_messages : [exception.message]
+      errors = if exception.respond_to?(:record)
+                exception.record.errors.full_messages
+              elsif exception.respond_to?(:errors)
+                exception.errors
+              else
+                [exception.message]
+              end
+
       notify_and_render_error(
         message: 'Validation failed',
         status: :unprocessable_entity,
@@ -33,16 +140,59 @@ module Dislogger
       )
     end
 
+    def handle_conflict(exception)
+      notify_and_render_error(
+        message: exception.message || 'Resource conflict',
+        status: :conflict
+      )
+    end
+
+    def handle_timeout(exception)
+      notify_and_render_error(
+        message: exception.message || 'Request timeout',
+        status: :request_timeout
+      )
+    end
+
+    def handle_foreign_key_error(exception)
+      notify_and_render_error(
+        message: 'Cannot delete or update due to database constraint',
+        status: :unprocessable_entity,
+        details: [exception.message]
+      )
+    end
+
+    def handle_unauthorized(exception)
+      notify_and_render_error(
+        message: exception.message || 'Unauthorized access',
+        status: :unauthorized
+      )
+    end
+
     def handle_forbidden(exception)
       notify_and_render_error(
-        message: exception.message.presence || 'You are not authorized to perform this action',
+        message: exception.message.presence || 'Access forbidden',
         status: :forbidden
       )
     end
 
+    def handle_not_acceptable(exception)
+      notify_and_render_error(
+        message: exception.message || 'Not acceptable',
+        status: :not_acceptable
+      )
+    end
+
+    def handle_bad_request(exception)
+      notify_and_render_error(
+        message: exception.message || 'Bad request',
+        status: :bad_request
+      )
+    end
+
     def handle_internal_server_error(exception)
       notify_and_render_error(
-        message: 'Internal Server Error',
+        message: exception.message || 'Internal server error',
         status: :internal_server_error,
         backtrace: exception.backtrace
       )
@@ -51,23 +201,42 @@ module Dislogger
     def notify_and_render_error(message:, status:, details: nil, backtrace: nil)
       status_code = Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
 
-      Notifiers::DiscordNotifier.new.notify(
+      notifier = Notifiers::DiscordNotifier.new
+      notification_result = notifier.notify(
         message: message,
         status: status_code,
         backtrace: backtrace
       )
 
-      render_error(message, status, details)
+      Rails.logger.info("[Dislogger] Notification result: #{notification_result}") if defined?(Rails)
+
+      render_error(message, status, error_details)
     end
 
     def render_error(message, status, details = nil)
       error_response = {
         status: status,
-        message: message
+        message: message,
+        timestamp: Time.current.utc.iso8601
       }
       error_response[:details] = details if details
 
       render json: error_response, status: status
     end
+
+    private
+
+    def filter_sensitive_params(params_hash)
+      # List of sensitive parameters we don't want to show
+      sensitive_params = %w[password password_confirmation token api_key secret]
+      
+      params_hash.deep_transform_values do |value|
+        if sensitive_params.any? { |param| value.to_s.include?(param) }
+          '[FILTERED]'
+        else
+          value
+        end
+      end
+    end
   end
 end 

data/lib/dislogger/notifiers/discord_notifier.rb

@@ -4,22 +4,21 @@ module Dislogger
   module Notifiers
     class DiscordNotifier < BaseNotifier
       def notify(message:, status:, backtrace: nil)
-        return unless enabled? && @config.discord_webhook_url.present?
+        return false unless enabled? && @config.discord_webhook_url.present?
 
+        log_info("Attempting to send Discord notification")
         formatted_message = format_message(message, status, backtrace)
         send_notification(formatted_message)
       rescue StandardError => e
-        if defined?(Rails) && Rails.logger
-          Rails.logger.error("Discord notification failed: #{e.message}")
-        else
-          warn("Discord notification failed: #{e.message}")
-        end
+        log_error("Discord notification failed: #{e.message}")
+        log_error(e.backtrace.join("\n")) if e.backtrace
         false
       end
 
       protected
 
       def format_message(message, status, backtrace)
+        log_info("Formatting Discord message")
         Formatters::DiscordFormatter.new(
           message: message,
           status: status,
@@ -29,6 +28,7 @@ module Dislogger
       end
 
       def send_notification(payload)
+        log_info("Sending notification to Discord")
         response = HTTParty.post(
           @config.discord_webhook_url,
           body: payload.to_json,
@@ -37,19 +37,40 @@ module Dislogger
         
         unless response.success?
           error_message = "Discord API Error: #{response.code} - #{response.body}"
-          if defined?(Rails) && Rails.logger
-            Rails.logger.error(error_message)
-          else
-            warn(error_message)
-          end
+          log_error(error_message)
           return false
         end
         
+        log_info("Discord notification sent successfully")
         true
+      rescue StandardError => e
+        log_error("Failed to send Discord notification: #{e.message}")
+        log_error(e.backtrace.join("\n")) if e.backtrace
+        false
       end
 
       def enabled?
-        @config.enabled?
+        result = @config.enabled?
+        log_info("Dislogger enabled? #{result} (environment: #{@config.environment}, enabled_environments: #{@config.enabled_environments})")
+        result
+      end
+
+      private
+
+      def log_info(message)
+        if defined?(Rails) && Rails.logger
+          Rails.logger.info("[Dislogger] #{message}")
+        else
+          puts "[Dislogger] #{message}"
+        end
+      end
+
+      def log_error(message)
+        if defined?(Rails) && Rails.logger
+          Rails.logger.error("[Dislogger] #{message}")
+        else
+          warn "[Dislogger] #{message}"
+        end
       end
     end
   end

data/lib/dislogger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dislogger
-  VERSION = "0.1.8"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dislogger
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - Nelson