Update config template (#17)

and allow lazy resolution of the job class from name, so that Rails may
reload/autoload the class.

lib/munster/base_handler.rb

@@ -16,7 +16,15 @@ def handle(action_dispatch_request)
       webhook = Munster::ReceivedWebhook.new(request: action_dispatch_request, handler_event_id: handler_event_id, handler_module_name: handler_module_name)
       webhook.save!
 
-      Munster.configuration.processing_job_class.perform_later(webhook)
+      # The configured job class can be a class name or a module, to support lazy loading
+      job_class_or_module_name = Munster.configuration.processing_job_class
+      job_class = if job_class_or_module_name.respond_to?(:perform_later)
+        job_class_or_module_name
+      else
+        job_class_or_module_name.constantize
+      end
+
+      job_class.perform_later(webhook)
     rescue ActiveRecord::RecordNotUnique # Webhook deduplicated
       Rails.logger.info { "#{inspect} Webhook #{handler_event_id} is a duplicate delivery and will not be stored." }
     end

lib/munster/templates/munster.rb

@@ -1,10 +1,15 @@
 Munster.configure do |config|
   # Active Handlers are defined as hash with key as a service_id and handler class  that would handle webhook request.
+  # A Handler must respond to `.new` and return an object roughly matching `Munster::BaseHandler` in terms of interface.
+  # Use module names (strings) here to allow the handler modules to be lazy-loaded by Rails.
+  #
   # Example:
-  #   {:test => TestHandler, :inactive => InactiveHandler}
+  #   {:test => "TestHandler", :inactive => "InactiveHandler"}
   config.active_handlers = {}
 
-  # It's possible to overwrite default processing job to enahance it. As example if you want to add proper locking or retry mechanism.
+  # It's possible to overwrite default processing job to enahance it. As example if you want to add custom
+  # locking or retry mechanism. You want to inherit that job from Munster::ProcessingJob because the background
+  # job also manages the webhook state.
   #
   # Example:
   #
@@ -15,14 +20,21 @@
   #     end
   #   end
   #
-  # This is how you can change processing job:
+  # In the config a string with your job' class name can be used so that the job can be lazy-loaded by Rails:
   #
-  # config.processing_job_class = WebhookProcessingJob
+  # config.processing_job_class = "WebhookProcessingJob"
 
   # We're using a common interface for error reporting provided by Rails, e.g Rails.error.report. In some cases
   # you want to enhance those errors with additional context. As example to provide a namespace:
   #
   # { appsignal: { namespace: "webhooks" } }
   #
   # config.error_context = { appsignal: { namespace: "webhooks" } }
+
+  # Incoming webhooks will be written into your DB without any prior validation. By default, Munster limits the
+  # request body size for webhooks to 512 KiB, so that it would not be too easy for an attacker to fill your
+  # database with junk. However, if you are receiving very large webhook payloads you might need to increase
+  # that limit (or make it even smaller for extra security)
+  #
+  # config.request_body_size_limit = 2.megabytes
 end