event_trigger 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39c0803bd55c50a4d09940dc90870adcbc78170e5637492808914cb809d9617b
-  data.tar.gz: 51cba5d01cd0528446a26fb23784c25227919b7a44b21ef05abb9d40f98d2f58
+  metadata.gz: fe43ce630c79111cd2c038186f60a7fbf7130ffe2907d6ab38e95d9e7cfbb1c8
+  data.tar.gz: 8618fa832234644c1060f4dde3b4549bef92a832af6bfff34f7b783b4804abbd
 SHA512:
-  metadata.gz: '09db06666e34aa573d1651cb4d9dfdeaadbc967699f5bdc2fd0d23b344f8efe829afe97d3c175f3ba333894f7aec08a833cf4a6644c56bb06e37735e510d3d79'
-  data.tar.gz: 86c01b75ebad0a5d4ee400f2feb6f03cc5c1e5ccf2bc2eeae1131cb5e8ef0c595d0f761ce78f396431bc103048ee47030bb38c7adf451c548e8a645bc0959b27
+  metadata.gz: 015e5be5caa07396a767ba1702f87f547eceaea17c6c27eebc3be3e76d54f20fa7502301a47f93840f4bca17b41fc32b6c2f34dd2ac19f9c2b68a44860ab53aa
+  data.tar.gz: 4820ccdc4149f082b6f6647086503c0d17f5dabec9274107354a189247bf3c16e38f23b85f68bd6155fe19278f2d4fbc7cadddb86473b204f87a21f6a0dad026

data/README.md

@@ -71,8 +71,61 @@ config.slack.events = nil  # or [] → all events
 
 ### Rails initializer
 
-Copy `examples/initializer.rb` to `config/initializers/event_trigger.rb`.
-A Railtie is shipped so the gem loads cleanly inside Rails.
+Generate the default config (recommended):
+
+```sh
+rails generate event_trigger:install
+# overwrite an existing one:
+rails generate event_trigger:install --force
+```
+
+This copies `config/initializers/event_trigger.rb` into your app:
+
+```ruby
+EventTrigger.configure do |config|
+  config.enabled = true
+
+  config.slack.enabled = true
+  config.slack.webhook_url = ENV["SLACK_WEBHOOK_URL"]
+  # NEW: Slack Web API mode (additive) — set BOTH to use chat.postMessage:
+  # config.slack.token = ENV["SLACK_BOT_TOKEN"]
+  # config.slack.channel = ENV["SLACK_CHANNEL"]
+  config.slack.events = nil # or your event names
+
+  config.email.enabled = false
+  # Rails apps: uncomment for ActionMailer delivery:
+  # config.email.delivery_method = :action_mailer
+  config.email.from = ENV["EVENT_TRIGGER_EMAIL_FROM"]
+  # NEW: spec-style SMTP hash also works (string/symbol keys):
+  # config.email.smtp = {
+  #   address: ENV["SMTP_ADDRESS"], port: ENV["SMTP_PORT"],
+  #   username: ENV["SMTP_USERNAME"], password: ENV["SMTP_PASSWORD"]
+  # }
+  config.email.events = nil
+
+  config.webhook.enabled = false
+  # NEW: config.webhook[:method] = :post  # :post/:put/:patch/:delete/:get
+  config.discord.enabled = false
+  config.whatsapp.enabled = false
+  # NEW providers (all disabled by default):
+  # config.telegram.enabled = true
+  # config.telegram.bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+  # config.telegram.chat_id = ENV["TELEGRAM_CHAT_ID"]
+  # config.teams.enabled = true
+  # config.teams.access_token = ENV["TEAMS_ACCESS_TOKEN"]
+  # config.teams.team_id = ENV["TEAMS_TEAM_ID"]
+  # config.teams.channel_id = ENV["TEAMS_CHANNEL_ID"]
+  # config.sms.enabled = true  # provider :twilio (Twilio Messaging API)
+  # config.sms.account_sid = ENV["TWILIO_ACCOUNT_SID"]
+  # config.sms.auth_token = ENV["TWILIO_AUTH_TOKEN"]
+  # config.sms.from = ENV["TWILIO_FROM"]
+end
+```
+
+No generator run? The gem's Railtie auto-applies these defaults on
+boot and auto-creates the initializer file when missing (never
+overwrites). Manual alternative: copy `examples/initializer.rb` to
+`config/initializers/event_trigger.rb`.
 
 ## Triggering events
 
@@ -84,6 +137,22 @@ Rules: `loan.activated` with Slack+Email enabled and subscribed runs both;
 `loan.overdue` with only Slack subscribed runs Slack only; with
 `config.enabled = false` nothing runs.
 
+`trigger` still returns the `Event` (unchanged). NEW additive result:
+the provider-wise map is exposed without changing the return value:
+
+```ruby
+event = EventTrigger.trigger("loan.activated", data: { loan_id: 123 })
+EventTrigger.last_result
+# => { event: "loan.activated", status: "success",
+#      providers: { slack: "sent", email: "sent", discord: "skipped (disabled)",
+#                   telegram: "skipped (disabled)", teams: "skipped (disabled)",
+#                   sms: "skipped (disabled)", webhook: "sent" } }
+event.last_result # same hash
+```
+
+Statuses: `"sent"` | `"failed"` | `"skipped ..."` (reason included).
+One provider failing never stops the others (isolation preserved).
+
 ## Handlers
 
 ```ruby
@@ -146,17 +215,6 @@ config.whatsapp.events = ["app.error"]
 Per-trigger override: `data: { whatsapp_to: "whatsapp:+919..." }`.
 Numbers without the `whatsapp:` scheme are normalized automatically.
 
-## Crash safety
-
-Every new provider follows the same contract as the old ones:
-- Missing config / missing `twilio-ruby` gem / network errors raise
-  `EventTrigger::Error` inside `#deliver` only.
-- `EventTrigger::Dispatcher` rescues per provider, logs
-  `provider ':x' failed ...`, and keeps running the rest — **the host
-  app never crashes because a notification failed**.
-- HTTP providers (Slack/Webhook/Discord) try stdlib `Net::HTTP`
-  first and fall back to `Faraday` when installed.
-
 ## Logging
 
 Set `config.logger`. Logs: event triggered, provider executed, provider

data/lib/event_trigger/configuration.rb

@@ -36,6 +36,18 @@ module EventTrigger
     # Generic option bag for provider-specific settings
     # (webhook_url, from, url, ...). Allows:
     #   config.slack.webhook_url = "..."
+    #
+    # NOTE: `config[:key]` reads raw options without hitting Ruby's own
+    # methods (e.g. `config.method` would call Object#method, so use
+    # `config[:method]` for the webhook HTTP verb).
+    def [](key)
+      @options[safe_key(key)]
+    end
+
+    def []=(key, value)
+      @options[safe_key(key)] = value
+    end
+
     def method_missing(name, *args)
       name_str = name.to_s
       if name_str.end_with?("=")
@@ -60,12 +72,29 @@ module EventTrigger
     def to_h
       { enabled: enabled, events: events }.merge(@options)
     end
+
+    private
+
+    # Never let a non-symbolizable key raise (e.g. Integer keys).
+    def safe_key(key)
+      key.respond_to?(:to_sym) ? key.to_sym : key.to_s.to_sym
+    rescue StandardError
+      key.to_s
+    end
   end
 
   # Global configuration object yielded by EventTrigger.configure.
   class Configuration
-    attr_accessor :enabled, :logger
-    attr_reader :slack, :email, :webhook, :discord, :whatsapp
+    # Hard safety net: no provider call may hang a host app forever.
+    # 0 (or nil) disables the timeout. Per-provider override:
+    #   config.slack.delivery_timeout = 5
+    DEFAULT_DELIVERY_TIMEOUT = 15
+    # Handlers are NOT time-limited by default (0 = disabled) because a
+    # killed handler could leave partial work behind. Set to enable.
+    DEFAULT_HANDLER_TIMEOUT = 0
+
+    attr_accessor :enabled, :logger, :delivery_timeout, :handler_timeout
+    attr_reader :slack, :email, :webhook, :discord, :whatsapp, :telegram, :teams, :sms
 
     # Backwards-compatible top-level shortcuts required by the spec:
     #   config.slack_webhook_url = ENV["SLACK_WEBHOOK_URL"]
@@ -74,14 +103,30 @@ module EventTrigger
     def initialize
       @enabled = true
       @logger = nil
+      @delivery_timeout = DEFAULT_DELIVERY_TIMEOUT
+      @handler_timeout = DEFAULT_HANDLER_TIMEOUT
       @slack = ProviderConfig.new
       @email = ProviderConfig.new
       @webhook = ProviderConfig.new
       @discord = ProviderConfig.new
       @whatsapp = ProviderConfig.new
+      @telegram = ProviderConfig.new
+      @teams = ProviderConfig.new
+      @sms = ProviderConfig.new
       @custom = {}
     end
 
+    # Effective timeout for one provider (per-provider wins, then global).
+    def timeout_for(provider_config)
+      per_provider = begin
+        provider_config[:delivery_timeout]
+      rescue StandardError
+        nil
+      end
+      value = per_provider.nil? ? @delivery_timeout : per_provider
+      value.nil? ? DEFAULT_DELIVERY_TIMEOUT : value.to_f
+    end
+
     def slack_webhook_url
       slack.webhook_url
     end
@@ -117,6 +162,9 @@ module EventTrigger
       when :webhook then webhook
       when :discord then discord
       when :whatsapp then whatsapp
+      when :telegram then telegram
+      when :teams then teams
+      when :sms then sms
       else
         @custom[key] ||= ProviderConfig.new
       end
@@ -124,9 +172,12 @@ module EventTrigger
     alias provider for
 
     # All provider configs keyed by name, including custom ones.
+    # Order here is the dispatch order (existing providers first so
+    # old result hashes keep their key order for backwards compat).
     def providers
       { slack: slack, email: email, webhook: webhook,
-        discord: discord, whatsapp: whatsapp }.merge(@custom)
+        discord: discord, whatsapp: whatsapp,
+        telegram: telegram, teams: teams, sms: sms }.merge(@custom)
     end
 
     def enabled?

data/lib/event_trigger/defaults.rb

@@ -17,6 +17,7 @@ module EventTrigger
   #     config.email.from = ENV["EVENT_TRIGGER_EMAIL_FROM"]
   #     ...
   #   end
+  # Never raises: called from the Railtie at boot time.
   def self.apply_defaults!(logger: nil)
     configure do |config|
       config.enabled = true
@@ -46,6 +47,28 @@ module EventTrigger
       config.whatsapp.twilio_from ||= ENV["TWILIO_WHATSAPP_FROM"]
       config.whatsapp.twilio_to ||= ENV["TWILIO_WHATSAPP_TO"]
       config.whatsapp.events ||= []
+
+      # NEW providers default to disabled + unsubscribed; enabling them
+      # is purely opt-in so existing apps see no behaviour change.
+      config.telegram.enabled = false
+      config.telegram.bot_token ||= ENV["TELEGRAM_BOT_TOKEN"]
+      config.telegram.chat_id ||= ENV["TELEGRAM_CHAT_ID"]
+      config.telegram.events ||= []
+
+      config.teams.enabled = false
+      config.teams.access_token ||= ENV["TEAMS_ACCESS_TOKEN"]
+      config.teams.team_id ||= ENV["TEAMS_TEAM_ID"]
+      config.teams.channel_id ||= ENV["TEAMS_CHANNEL_ID"]
+      config.teams.events ||= []
+
+      config.sms.enabled = false
+      config.sms.provider ||= :twilio
+      config.sms.account_sid ||= ENV["TWILIO_ACCOUNT_SID"]
+      config.sms.auth_token ||= ENV["TWILIO_AUTH_TOKEN"]
+      config.sms.from ||= ENV["TWILIO_FROM"]
+      config.sms.events ||= []
     end
+  rescue StandardError
+    nil
   end
 end

data/lib/event_trigger/dispatcher.rb

@@ -1,70 +1,210 @@
 # frozen_string_literal: true
 
+require "timeout"
+
 module EventTrigger
   # Fans an Event out to every enabled provider subscribed to that event,
   # then runs any user-registered handlers (EventTrigger.on).
   #
-  # Guarantees:
+  # Safety contract (never harms the host app or system):
   # - Global disable (config.enabled == false) => nothing runs.
   # - Only enabled providers subscribed to the event run.
   # - Unknown provider names are skipped (with a log line) instead of crashing.
   # - One provider raising never prevents the others from running;
   #   failures are logged and swallowed so all providers always run.
-  # - Handler blocks are likewise isolated: a failing handler is logged
-  #   and the rest still run.
+  # - Every provider call is wrapped in a hard timeout
+  #   (config.delivery_timeout, default 15s; per-provider override via
+  #   config.<provider>.delivery_timeout) so a hanging API can never block
+  #   a web request forever. 0 disables the timeout.
+  # - Handler blocks are isolated: a failing handler is logged and the rest
+  #   still run. Optional handler timeout via config.handler_timeout (0 = off).
+  # - Logging failures (closed IO, disk full, broken custom logger) are
+  #   swallowed — a logger must never break dispatch.
+  # - #dispatch itself never raises: any internal error is captured.
+  #
+  # Result shape (additive):
+  #   { event:, status:, providers: { slack: "sent", email: "failed", ... } }
+  # statuses: "sent" | "failed" | "skipped ..." (reason included).
   class Dispatcher
+    SKIP_DISABLED = "skipped (disabled)"
+    SKIP_UNSUBSCRIBED_PREFIX = "skipped (not subscribed"
+    SKIP_UNREGISTERED = "skipped (unregistered)"
+    STATUS_SENT = "sent"
+    STATUS_FAILED = "failed"
+    STATUS_ERROR = "error"
+    UNKNOWN = "<unknown>"
+    SECRET_KEYS = %w[token secret password passwd api_key apikey auth authorization bearer webhook sid].freeze
+
     def initialize(configuration)
       @configuration = configuration
     end
 
-    # Returns the list of provider instances that were executed.
+    # Returns the provider-wise result hash. Still runs handlers.
+    # Never raises.
     def dispatch(event, handlers = [])
-      log("event triggered: #{event.name} payload=#{event.payload.inspect}")
-      return [] unless @configuration.enabled?
-
-      executed = []
-      providers_for(event.name).each do |name, provider_config|
-        klass = Registry.fetch(name)
-        if klass.nil?
-          log("provider ':#{name}' has no registered class; skipping")
-          next
-        end
-        unless provider_config.enabled
-          log("provider ':#{name}' skipped (disabled)")
-          next
-        end
-        unless provider_config.subscribed_to?(event.name)
-          log("provider ':#{name}' skipped (not subscribed to '#{event.name}')")
-          next
-        end
-        begin
-          klass.new(config: provider_config, global_config: @configuration).deliver(event)
-          log("provider ':#{name}' executed for '#{event.name}'")
-          executed << name
-        rescue StandardError => e
-          log("provider ':#{name}' failed for '#{event.name}': #{e.class}: #{e.message}")
-        end
+      log("event triggered: #{event_name(event)} payload=#{redact_payload(payload_of(event))}")
+      return build_result(event, {}, disabled_globally: true) unless globally_enabled?
+
+      statuses = {}
+      providers_snapshot.each { |name, cfg| statuses[name] = run_provider(name, cfg, event) }
+      run_handlers(handlers, event)
+      build_result(event, statuses)
+    rescue StandardError => e
+      # Absolute last line of defence: a bug inside the dispatcher itself
+      # must never surface in the host app.
+      log("dispatcher error for '#{event_name(event)}': #{e.class}: #{redact(e.message)}")
+      build_result(event, {}, internal_error: "#{e.class}: #{redact(e.message)}")
+    end
+
+    private
+
+    # Snapshot so concurrent configuration changes can't break iteration.
+    def providers_snapshot
+      @configuration.providers.to_a
+    rescue StandardError
+      []
+    end
+
+    def globally_enabled?
+      @configuration.enabled?
+    rescue StandardError
+      true
+    end
+
+    def run_provider(name, provider_config, event)
+      klass = Registry.fetch(name)
+      if klass.nil?
+        log("provider ':#{name}' has no registered class; skipping")
+        return SKIP_UNREGISTERED
+      end
+      unless provider_config.enabled
+        log("provider ':#{name}' skipped (disabled)")
+        return SKIP_DISABLED
+      end
+      unless provider_config.subscribed_to?(event_name(event))
+        log("provider ':#{name}' skipped (not subscribed to '#{event_name(event)}')")
+        return "#{SKIP_UNSUBSCRIBED_PREFIX} to '#{event_name(event)}')"
       end
 
-      Array(handlers).each do |handler|
-        begin
+      deliver_with_timeout(klass, name, provider_config, event)
+      log("provider ':#{name}' executed for '#{event_name(event)}'")
+      STATUS_SENT
+    rescue StandardError => e
+      log("provider ':#{name}' failed for '#{event_name(event)}': #{e.class}: #{redact(e.message)}")
+      STATUS_FAILED
+    end
+
+    # Hard timeout guard around the provider call (covers slow DNS, hung
+    # sockets, Twilio/SMTP stalls...). Timeout::Error is a StandardError,
+    # so it is reported as "failed" and the loop continues.
+    def deliver_with_timeout(klass, name, provider_config, event)
+      timeout = timeout_for(provider_config)
+      instance = klass.new(config: provider_config, global_config: @configuration)
+      return instance.deliver(event) if timeout.nil? || timeout <= 0
+
+      Timeout.timeout(timeout, Error, "provider ':#{name}' timed out after #{timeout}s") do
+        instance.deliver(event)
+      end
+    end
+
+    def timeout_for(provider_config)
+      @configuration.timeout_for(provider_config)
+    rescue StandardError
+      Configuration::DEFAULT_DELIVERY_TIMEOUT
+    end
+
+    def run_handlers(handlers, event)
+      Array(handlers).each { |handler| run_handler(handler, event) }
+    rescue StandardError => e
+      log("handler iteration failed: #{e.class}: #{redact(e.message)}")
+    end
+
+    def run_handler(handler, event)
+      return unless handler.respond_to?(:call)
+
+      timeout = handler_timeout
+      if timeout.nil? || timeout <= 0
+        handler.call(event)
+      else
+        Timeout.timeout(timeout, Error, "handler for '#{event_name(event)}' timed out after #{timeout}s") do
           handler.call(event)
-        rescue StandardError => e
-          log("handler for '#{event.name}' failed: #{e.class}: #{e.message}")
         end
       end
+    rescue StandardError => e
+      log("handler for '#{event_name(event)}' failed: #{e.class}: #{redact(e.message)}")
+    end
 
-      executed
+    def handler_timeout
+      value = @configuration.handler_timeout
+      value.nil? ? 0 : value.to_f
+    rescue StandardError
+      0
     end
 
-    private
+    def build_result(event, statuses, disabled_globally: false, internal_error: nil)
+      if disabled_globally
+        statuses = providers_snapshot.map { |k, _| [k, SKIP_DISABLED] }.to_h
+      end
+      # Overall status mirrors the documented API shape:
+      # "success" unless the dispatcher itself blew up.
+      result = { event: event_name(event), status: "success", providers: statuses }
+      return result unless internal_error
+
+      result.merge(status: STATUS_ERROR, error: internal_error)
+    end
 
-    def providers_for(_event_name)
-      @configuration.providers
+    # Safe accessor: an Event-like object whose #name raises must not
+    # break the dispatcher.
+    def event_name(event)
+      event.respond_to?(:name) ? event.name.to_s : UNKNOWN
+    rescue StandardError
+      UNKNOWN
     end
 
+    def payload_of(event)
+      event.payload
+    rescue StandardError
+      {}
+    end
+
+    # Logging must never break dispatch (closed IO, disk full, broken
+    # custom logger, ...).
     def log(message)
-      @configuration.logger&.info("[EventTrigger] #{message}")
+      logger = @configuration.logger
+      return unless logger.respond_to?(:info)
+
+      logger.info("[EventTrigger] #{message}")
+    rescue StandardError
+      nil
+    end
+
+    # Never log credential-looking fragments (tokens, passwords, ...).
+    def redact(message)
+      str = message.to_s.dup
+      SECRET_KEYS.each do |key|
+        str.gsub!(/#{key}[^,\s\]}]*[\w\-\.\/~+=\/]+/i, "#{key}=[FILTERED]")
+      end
+      str
+    rescue StandardError
+      "[unprintable]"
+    end
+
+    # Payload logging is capped: a huge payload must not bloat logs/memory.
+    def redact_payload(payload, limit = 2000)
+      return "{}" unless payload.is_a?(Hash)
+
+      redacted = payload.each_with_object({}) { |(k, v), memo| memo[k] = secret_key?(k) ? "[FILTERED]" : v }
+      text = redacted.inspect
+      text.length > limit ? "#{text[0, limit]}…(truncated)" : text
+    rescue StandardError
+      "{}"
+    end
+
+    def secret_key?(key)
+      k = key.to_s.downcase
+      SECRET_KEYS.any? { |s| k.include?(s) }
+    rescue StandardError
+      false
     end
   end
 end

data/lib/event_trigger/event.rb

@@ -6,15 +6,27 @@ module EventTrigger
   # (anything the caller passes via data:), and a timestamp.
   class Event
     attr_reader :name, :payload, :timestamp
+    # Provider-wise result hash for this event's dispatch
+    # ({ event:, status:, providers: }). Set by EventTrigger.trigger.
+    attr_accessor :last_result
 
     def initialize(name:, payload: {})
       @name = name.to_s
       @payload = symbolize(payload || {})
       @timestamp = Time.now
+      @last_result = nil
     end
 
+    # Safe lookup: works with symbols, strings and non-symbolizable keys.
     def [](key)
-      payload[key.to_sym] || payload[key.to_s]
+      sym = begin
+        key.to_sym
+      rescue StandardError
+        nil
+      end
+      return payload[sym] if sym && payload.key?(sym)
+
+      payload[key.to_s]
     end
 
     def to_h
@@ -23,12 +35,22 @@ module EventTrigger
 
     private
 
+    # Defensive: non-Hash payloads become {}, and odd keys (Integer,
+    # objects without #to_sym) fall back to strings instead of raising.
+    # This guarantees Event.new can never crash the caller.
     def symbolize(hash)
       return {} unless hash.is_a?(Hash)
 
       hash.each_with_object({}) do |(k, v), memo|
-        memo[k.to_sym] = v
+        key = begin
+          k.respond_to?(:to_sym) ? k.to_sym : k.to_s
+        rescue StandardError
+          k.to_s
+        end
+        memo[key] = v
       end
+    rescue StandardError
+      {}
     end
   end
 end

data/lib/event_trigger/provider.rb

@@ -12,11 +12,18 @@ module EventTrigger
   #   end
   #   EventTrigger.register_provider(:sms, SmsProvider)
   #
+  # Normalized alias: #send(event_name, data) builds an Event and
+  # delegates to #deliver. Built-in providers implement it; custom
+  # providers get a default that does the same.
+  #
   # Helpers available to subclasses:
   #   - #config        -> ProviderConfig for this provider
   #   - #global_config -> full EventTrigger::Configuration
-  #   - #log(message)  -> write to configured logger, if any
+  #   - #log(message)  -> write to configured logger, if any (never logs credentials)
   class Provider
+    # Keys that must never appear in logs (case-insensitive substring match).
+    SECRET_KEYS = %w[token secret password passwd api_key apikey auth authorization bearer webhook].freeze
+
     attr_reader :config, :global_config
 
     def initialize(config:, global_config:)
@@ -29,6 +36,41 @@ module EventTrigger
       raise NotImplementedError, "#{self.class} must implement #deliver(event)"
     end
 
+    # Normalized interface: provider.send(event_name, data)
+    #
+    # NOTE: this intentionally shadows Ruby's Object#send for the
+    # notification signature. Calls that are clearly internal Ruby sends
+    # are forwarded to Object#send so frameworks/reflection keep working:
+    #   provider.send(:deliver, event)      -> Object#send
+    #   provider.send(:some_helper, 1, 2)   -> Object#send
+    #   provider.send("loan.activated", {}) -> notification (deliver)
+    #   provider.send("loan.activated")     -> notification (empty payload)
+    # Ambiguous single-symbol form (provider.send(:foo)) is treated as
+    # Object#send; pass a String event name (or a data Hash) to notify.
+    def send(event_name, *args, &block)
+      notification =
+        if args.size == 1
+          args.first.nil? || args.first.is_a?(Hash)
+        elsif args.empty?
+          !event_name.is_a?(Symbol)
+        else
+          false
+        end
+
+      return __send__(event_name, *args, &block) unless notification
+
+      deliver(Event.new(name: event_name.to_s, payload: args.first || {}))
+    end
+
+    # Normalized result wrapper: { provider:, status:, error: }.
+    # Never raises — failures are captured, never stop other providers.
+    def safe_send(event_name, data = {})
+      send(event_name, data)
+      { provider: provider_name, status: "sent", error: nil }
+    rescue StandardError => e
+      { provider: provider_name, status: "failed", error: "#{e.class}: #{e.message}" }
+    end
+
     # Symbolic name derived from class name, e.g. SlackProvider -> :slack.
     # Custom providers can override .provider_name.
     def self.provider_name
@@ -43,7 +85,22 @@ module EventTrigger
 
     def log(message)
       logger = global_config.logger
-      logger&.info("[EventTrigger][#{provider_name}] #{message}")
+      return unless logger.respond_to?(:info)
+
+      logger.info("[EventTrigger][#{provider_name}] #{redact(message)}")
+    rescue StandardError
+      nil
+    end
+
+    # Strip credential-looking fragments before they reach the log.
+    def redact(message)
+      str = message.to_s
+      SECRET_KEYS.each do |key|
+        str = str.gsub(/#{key}[^,\s\]}]*[\w\-\.\/~\+=\/]+/i, "#{key}=[FILTERED]")
+      end
+      str
+    rescue StandardError
+      "[unprintable]"
     end
   end
 end

data/lib/event_trigger/providers/discord_provider.rb

@@ -13,7 +13,7 @@ module EventTrigger
     #   config.discord.enabled = true
     #   config.discord.webhook_url = ENV["DISCORD_WEBHOOK_URL"]
     #   config.discord.username = "RailsErrorNotifier"  # optional
-    #   config.discord.events = ["app.error"]
+    #   config.discord.events = ["loan.activated", "loan.overdue"]
     #
     # Crash-safe: failures raise EventTrigger::Error, which the
     # Dispatcher logs — the host app never crashes because of Discord.
@@ -30,11 +30,12 @@ module EventTrigger
         url = config.webhook_url || config.url
         raise Error, "Discord webhook_url is not configured" if url.nil? || url.to_s.strip.empty?
 
-        post_json(url.to_s, build_payload(event), service: "Discord")
+        post_json(url.to_s, build_payload(event), { "Content-Type" => "application/json" }, service: "Discord")
         log("delivered event '#{event.name}'")
         true
       end
 
+
       private
 
       def build_payload(event)
@@ -63,7 +64,7 @@ module EventTrigger
         truncate(err.to_s, 1500)
       end
 
-      def truncate(str, limit)
+      def truncate(str, limit = 1500)
         s = str.to_s
         s.length > limit ? "#{s[0, limit]}…" : s
       end