event_trigger 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2c3d6d3c6ba705815ec39d822e4a83d8d832a395b63eb85fd9b149e9cdc4a5e
-  data.tar.gz: 0e5339bc3d82788cdd942d0b7c69f979855379ac5f9c5b7ccde950617b46a9b8
+  metadata.gz: 39c0803bd55c50a4d09940dc90870adcbc78170e5637492808914cb809d9617b
+  data.tar.gz: 51cba5d01cd0528446a26fb23784c25227919b7a44b21ef05abb9d40f98d2f58
 SHA512:
-  metadata.gz: 399d0f668e2781a691c53bb6bc172ffbfc984656c50dc72e3eeda8831869209f1ac388c42faf6f5c3542bfa6aab9672c02d9c1a5730d7d85a0df4cdbe57f2930
-  data.tar.gz: 24811741cb39d9d792b138445754da696bdb4b514a4f194c4fbbbaed0b2b5854ab9c8a3285bc5ea40415a92182d3f1bf8269ef47d0c0d6d3e319cd65b7803ea6
+  metadata.gz: '09db06666e34aa573d1651cb4d9dfdeaadbc967699f5bdc2fd0d23b344f8efe829afe97d3c175f3ba333894f7aec08a833cf4a6644c56bb06e37735e510d3d79'
+  data.tar.gz: 86c01b75ebad0a5d4ee400f2feb6f03cc5c1e5ccf2bc2eeae1131cb5e8ef0c595d0f761ce78f396431bc103048ee47030bb38c7adf451c548e8a645bc0959b27

data/.ruby-version

@@ -0,0 +1 @@
+3.2.11

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+## [0.1.0] - 2026-09-18
+
+- Initial release: configurable event-based notifications (Slack, Email,
+  Webhook + custom providers), global/per-provider enable flags,
+  per-provider event allow-lists, handlers, failure isolation, logging,
+  Rails Railtie, RSpec suite.

data/README.md

@@ -14,7 +14,7 @@ Anything can be sent in `data:` -- passed through to providers/handlers.
 
 ## Features
 
-- Providers: **Slack**, **Email**, **Webhook**, plus custom providers
+- Providers: **Slack**, **Email**, **Webhook**, **Discord**, **WhatsApp (Twilio)**, plus custom providers
 - Central `EventTrigger.configure` block (plain Ruby and Rails)
 - Per-provider `enabled` flag + global `config.enabled` kill-switch
 - Per-provider `events` allow-list (`nil`/empty = all events)
@@ -115,7 +115,47 @@ EventTrigger.register_provider(:sms, SmsProvider)
 EventTrigger.configure { |c| c.for(:sms).enabled = true }
 ```
 
-Architecture: EventTrigger -> Event -> Enabled Providers (Slack/Email/Webhook).
+Architecture: EventTrigger -> Event -> Enabled Providers
+(Slack/Email/Webhook/Discord/WhatsApp).
+
+## Discord provider (`config.discord`)
+
+Ported from `RailsErrorNotifier`: posts the rich embed payload
+(`username: RailsErrorNotifier`, Backtrace/Context fields, ~1014-char
+truncation) to a Discord incoming-webhook URL.
+
+```ruby
+config.discord.enabled = true
+config.discord.webhook_url = ENV["DISCORD_WEBHOOK_URL"]
+config.discord.events = ["app.error"]
+```
+
+## WhatsApp provider (`config.whatsapp`, via Twilio)
+
+Ported from `RailsErrorNotifier`:
+
+```ruby
+config.whatsapp.enabled = true
+config.whatsapp.twilio_sid = ENV["TWILIO_ACCOUNT_SID"]
+config.whatsapp.twilio_token = ENV["TWILIO_AUTH_TOKEN"]
+config.whatsapp.twilio_from = ENV["TWILIO_WHATSAPP_FROM"] # whatsapp:+14155238886
+config.whatsapp.twilio_to = ENV["TWILIO_WHATSAPP_TO"]
+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
 

data/examples/initializer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Sample Rails initializer for EventTrigger.
+# Copy to your app as config/initializers/event_trigger.rb
+# and adjust values for your environment.
+
+EventTrigger.configure do |config|
+  config.enabled = true
+
+  config.slack.enabled = true
+  config.slack.webhook_url = ENV["SLACK_WEBHOOK_URL"]
+  config.slack.events = %w[
+    loan.activated
+    loan.overdue
+    payment.received
+  ]
+
+  config.email.enabled = false
+  config.email.from = ENV["EVENT_TRIGGER_EMAIL_FROM"]
+  config.email.to = ENV["EVENT_TRIGGER_EMAIL_TO"]
+  config.email.events = %w[
+    loan.activated
+    loan.foreclosed
+  ]
+
+  config.webhook.enabled = false
+  # config.webhook.url = ENV["EVENT_TRIGGER_WEBHOOK_URL"]
+  # config.webhook.events = %w[loan.activated]
+
+  # Optional logging (defaults to no logging):
+  # config.logger = Rails.logger
+end

data/examples/plain_ruby.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Plain-Ruby usage example (no Rails required).
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "event_trigger"
+require "logger"
+
+EventTrigger.configure do |config|
+  config.enabled = true
+  config.logger = Logger.new($stdout)
+
+  config.slack.enabled = true
+  config.slack.webhook_url = ENV["SLACK_WEBHOOK_URL"]
+  config.slack.events = ["loan.activated", "loan.overdue", "payment.received"]
+
+  config.email.enabled = false
+  config.email.from = ENV["EVENT_TRIGGER_EMAIL_FROM"]
+  config.email.to = "ops@example.com"
+  config.email.events = ["loan.activated", "loan.foreclosed"]
+
+  config.webhook.enabled = false
+end
+
+# Custom per-event logic alongside providers:
+EventTrigger.on("loan.activated") do |event|
+  puts "Custom handler saw loan #{event.payload[:loan_id]} for #{event.payload[:customer_name]}"
+end
+
+# Anything can be sent in `data:` -- it is passed through to providers/handlers.
+EventTrigger.trigger(
+  "loan.activated",
+  data: {
+    loan_id: 123,
+    customer_name: "Kamlesh"
+  }
+)
+
+# Error-style payload (Slack text vs Discord embed chosen automatically):
+EventTrigger.trigger(
+  "app.error",
+  data: {
+    error: "Something went wrong",
+    backtrace: caller.first(5),
+    context: { user_id: 42 }
+  }
+)

data/lib/event_trigger/configuration.rb

@@ -65,7 +65,7 @@ module EventTrigger
   # Global configuration object yielded by EventTrigger.configure.
   class Configuration
     attr_accessor :enabled, :logger
-    attr_reader :slack, :email, :webhook
+    attr_reader :slack, :email, :webhook, :discord, :whatsapp
 
     # Backwards-compatible top-level shortcuts required by the spec:
     #   config.slack_webhook_url = ENV["SLACK_WEBHOOK_URL"]
@@ -77,6 +77,8 @@ module EventTrigger
       @slack = ProviderConfig.new
       @email = ProviderConfig.new
       @webhook = ProviderConfig.new
+      @discord = ProviderConfig.new
+      @whatsapp = ProviderConfig.new
       @custom = {}
     end
 
@@ -96,6 +98,14 @@ module EventTrigger
       email.from = value
     end
 
+    def discord_webhook_url
+      discord.webhook_url
+    end
+
+    def discord_webhook_url=(value)
+      discord.webhook_url = value
+    end
+
     # Access (or lazily create) the config for any provider name,
     # including future/custom providers:
     #   config.for(:sms).enabled = true
@@ -105,6 +115,8 @@ module EventTrigger
       when :slack then slack
       when :email then email
       when :webhook then webhook
+      when :discord then discord
+      when :whatsapp then whatsapp
       else
         @custom[key] ||= ProviderConfig.new
       end
@@ -113,7 +125,8 @@ module EventTrigger
 
     # All provider configs keyed by name, including custom ones.
     def providers
-      { slack: slack, email: email, webhook: webhook }.merge(@custom)
+      { slack: slack, email: email, webhook: webhook,
+        discord: discord, whatsapp: whatsapp }.merge(@custom)
     end
 
     def enabled?

data/lib/event_trigger/defaults.rb

@@ -35,6 +35,17 @@ module EventTrigger
       config.webhook.url ||= ENV["EVENT_TRIGGER_WEBHOOK_URL"]
       # Leave webhook subscribed to nothing until the app opts in.
       config.webhook.events ||= []
+
+      config.discord.enabled = false
+      config.discord.webhook_url ||= ENV["DISCORD_WEBHOOK_URL"]
+      config.discord.events ||= []
+
+      config.whatsapp.enabled = false
+      config.whatsapp.twilio_sid ||= ENV["TWILIO_ACCOUNT_SID"]
+      config.whatsapp.twilio_token ||= ENV["TWILIO_AUTH_TOKEN"]
+      config.whatsapp.twilio_from ||= ENV["TWILIO_WHATSAPP_FROM"]
+      config.whatsapp.twilio_to ||= ENV["TWILIO_WHATSAPP_TO"]
+      config.whatsapp.events ||= []
     end
   end
 end

data/lib/event_trigger/providers/discord_provider.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../provider"
+require_relative "http_poster"
+
+module EventTrigger
+  module Providers
+    # Sends event notifications to Discord via an incoming-webhook URL,
+    # using a rich embed payload (ported from RailsErrorNotifier).
+    #
+    # Config:
+    #   config.discord.enabled = true
+    #   config.discord.webhook_url = ENV["DISCORD_WEBHOOK_URL"]
+    #   config.discord.username = "RailsErrorNotifier"  # optional
+    #   config.discord.events = ["app.error"]
+    #
+    # Crash-safe: failures raise EventTrigger::Error, which the
+    # Dispatcher logs — the host app never crashes because of Discord.
+    class DiscordProvider < Provider
+      include HttpPoster
+
+      MAX_FIELD_VALUE = 1024
+
+      def self.provider_name
+        :discord
+      end
+
+      def deliver(event)
+        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")
+        log("delivered event '#{event.name}'")
+        true
+      end
+
+      private
+
+      def build_payload(event)
+        payload = event.payload
+        backtrace_text = truncate_for_discord((payload[:backtrace] || payload["backtrace"] || ["No backtrace"]).first(10).join("\n"))
+        context_text = truncate_for_discord((payload[:context] || payload["context"] || payload).inspect)
+        {
+          username: config.username || "RailsErrorNotifier",
+          embeds: [
+            {
+              title: "🚨 Error Occurred",
+              description: embed_description(event, payload),
+              color: 0xFF0000,
+              fields: [
+                { name: "Backtrace", value: "```\n#{backtrace_text}\n```", inline: false },
+                { name: "Context", value: "```\n#{context_text}\n```", inline: false }
+              ],
+              timestamp: Time.now.utc.iso8601
+            }
+          ]
+        }
+      end
+
+      def embed_description(event, payload)
+        err = payload[:error] || payload["error"] || event.name
+        truncate(err.to_s, 1500)
+      end
+
+      def truncate(str, limit)
+        s = str.to_s
+        s.length > limit ? "#{s[0, limit]}…" : s
+      end
+
+      def truncate_for_discord(text)
+        truncate(text.to_s, MAX_FIELD_VALUE - 10) # leave room for ``` block
+      end
+    end
+  end
+end

data/lib/event_trigger/providers/http_poster.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module EventTrigger
+  module Providers
+    # Shared JSON POST helper with a Net::HTTP -> Faraday fallback chain.
+    #
+    # Primary transport is stdlib Net::HTTP (zero extra deps). If the
+    # request itself raises (DNS, timeout, connection error), it falls
+    # back to Faraday when available. HTTP error statuses raise
+    # EventTrigger::Error directly (no retry — same result expected).
+    module HttpPoster
+      private
+
+      def post_json(url, body, headers = { "Content-Type" => "application/json" }, service: "HTTP")
+        payload = JSON.generate(body)
+        begin
+          net_http_post(url, payload, headers, service)
+        rescue EventTrigger::Error
+          raise
+        rescue StandardError => e
+          faraday_post(url, payload, headers, service, e)
+        end
+      end
+
+      def net_http_post(url, payload, headers, service)
+        uri = URI.parse(url.to_s)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 10
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        request.body = payload
+        response = http.request(request)
+        unless response.is_a?(Net::HTTPSuccess)
+          raise Error, "#{service} delivery failed (HTTP #{response.code}): #{response.body}"
+        end
+        response
+      end
+
+      def faraday_post(url, payload, headers, service, original_error)
+        require "faraday"
+        response = Faraday.post(url.to_s, payload, headers)
+        unless response.success?
+          raise Error, "#{service} delivery failed (HTTP #{response.status}): #{response.body}"
+        end
+        response
+      rescue LoadError
+        raise original_error
+      end
+    end
+  end
+end

data/lib/event_trigger/providers/whatsapp_provider.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+begin
+  require "twilio-ruby"
+rescue LoadError
+  # Optional at load time: #deliver raises a clear EventTrigger::Error
+  # when the gem is missing, which the Dispatcher logs without
+  # crashing the host app.
+end
+
+require_relative "../provider"
+
+module EventTrigger
+  module Providers
+    # Sends event notifications via WhatsApp using Twilio
+    # (ported from RailsErrorNotifier).
+    #
+    # Config:
+    #   config.whatsapp.enabled = true
+    #   config.whatsapp.twilio_sid = ENV["TWILIO_ACCOUNT_SID"]
+    #   config.whatsapp.twilio_token = ENV["TWILIO_AUTH_TOKEN"]
+    #   config.whatsapp.twilio_from = "whatsapp:+14155238886"
+    #   config.whatsapp.twilio_to = "whatsapp:+919876543210"
+    #   config.whatsapp.events = ["app.error"]
+    #
+    # Aliases: account_sid/sid, auth_token/token, from/to.
+    # Per-trigger override: data: { whatsapp_to: "whatsapp:+..." }
+    #
+    # Crash-safe: missing gem/credentials/network errors raise
+    # EventTrigger::Error, which the Dispatcher logs — the host app
+    # never crashes because of WhatsApp.
+    class WhatsappProvider < Provider
+      MAX_BODY = 1000
+
+      def self.provider_name
+        :whatsapp
+      end
+
+      def deliver(event)
+        unless defined?(Twilio::REST::Client)
+          raise Error, 'twilio-ruby gem is not installed (add `gem "twilio-ruby"` to your Gemfile)'
+        end
+
+        sid = config.twilio_sid || config.account_sid || config.sid
+        token = config.twilio_token || config.auth_token || config.token
+        from = config.twilio_from || config.from
+        to = event.payload[:whatsapp_to] || event.payload["whatsapp_to"] ||
+             config.twilio_to || config.to
+
+        raise Error, "WhatsApp twilio_sid is not configured" if blank?(sid)
+        raise Error, "WhatsApp twilio_token is not configured" if blank?(token)
+        raise Error, "WhatsApp sender (twilio_from) is not configured" if blank?(from)
+        raise Error, "WhatsApp recipient (twilio_to) is not configured" if blank?(to)
+
+        client = Twilio::REST::Client.new(sid.to_s, token.to_s)
+        client.messages.create(
+          from: normalize_number(from),
+          to: normalize_number(to),
+          body: build_body(event)
+        )
+        log("delivered event '#{event.name}' to #{to}")
+        true
+      end
+
+      private
+
+      def build_body(event)
+        payload = event.payload
+        err = payload[:error] || payload["error"]
+        text =
+          if err
+            bt = payload[:backtrace] || payload["backtrace"]
+            first = Array(bt).first || "No backtrace"
+            ctx = payload[:context] || payload["context"]
+            msg = "🚨 Error: #{err}\nBacktrace: #{first}"
+            msg += "\nContext: #{ctx.inspect}" if ctx
+            msg
+          else
+            summary = payload.map { |k, v| "#{k}: #{v}" }.join(", ")
+            summary = payload.inspect if summary.empty?
+            "[#{event.name}] #{summary}"
+          end
+        truncate(text)
+      end
+
+      # Twilio requires the whatsapp: scheme; add it when missing.
+      def normalize_number(value)
+        s = value.to_s.strip
+        s.start_with?("whatsapp:") ? s : "whatsapp:#{s}"
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def truncate(str, limit = MAX_BODY)
+        s = str.to_s
+        s.length > limit ? "#{s[0, limit]}…" : s
+      end
+    end
+  end
+end

data/lib/event_trigger/registry.rb

@@ -24,15 +24,19 @@ module EventTrigger
         @providers.key?(name.to_sym)
       end
 
-      # Restore the three built-in providers (used by reset!).
+      # Restore the five built-in providers (used by reset!).
       def reset!
         @providers = {}
         require_relative "providers/slack_provider"
         require_relative "providers/email_provider"
         require_relative "providers/webhook_provider"
+        require_relative "providers/discord_provider"
+        require_relative "providers/whatsapp_provider"
         register(:slack, Providers::SlackProvider)
         register(:email, Providers::EmailProvider)
         register(:webhook, Providers::WebhookProvider)
+        register(:discord, Providers::DiscordProvider)
+        register(:whatsapp, Providers::WhatsappProvider)
       end
     end
   end

data/lib/event_trigger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EventTrigger
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/event_trigger.rb

@@ -8,6 +8,8 @@ require_relative "event_trigger/provider"
 require_relative "event_trigger/providers/slack_provider"
 require_relative "event_trigger/providers/email_provider"
 require_relative "event_trigger/providers/webhook_provider"
+require_relative "event_trigger/providers/discord_provider"
+require_relative "event_trigger/providers/whatsapp_provider"
 require_relative "event_trigger/dispatcher"
 require_relative "event_trigger/defaults"
 require_relative "event_trigger/railtie" if defined?(Rails::Railtie)

data/lib/generators/event_trigger/templates/event_trigger.rb

@@ -26,4 +26,17 @@ EventTrigger.configure do |config|
   config.webhook.url = ENV["EVENT_TRIGGER_WEBHOOK_URL"]
   # nil (or []) = ALL events.
   config.webhook.events = ["loan.activated"]
+
+  config.discord.enabled = false
+  config.discord.webhook_url = ENV["DISCORD_WEBHOOK_URL"]
+  # nil (or []) = ALL events.
+  config.discord.events = []
+
+  config.whatsapp.enabled = false
+  config.whatsapp.twilio_sid = ENV["TWILIO_ACCOUNT_SID"]
+  config.whatsapp.twilio_token = ENV["TWILIO_AUTH_TOKEN"]
+  config.whatsapp.twilio_from = ENV["TWILIO_WHATSAPP_FROM"]
+  config.whatsapp.twilio_to = ENV["TWILIO_WHATSAPP_TO"]
+  # nil (or []) = ALL events.
+  config.whatsapp.events = []
 end

metadata

@@ -1,15 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: event_trigger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kamlesh Parmar
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-18 00:00:00.000000000 Z
+date: 2026-09-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: twilio-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +92,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
 description: 'EventTrigger provides a simple event system with pluggable notification
   providers (Slack, Email, Webhook, custom). Configure providers once, then call EventTrigger.trigger("event.name",
   data: {...}) and the gem dispatches to the enabled providers configured for that
@@ -62,18 +116,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".ruby-version"
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/initializer.rb
+- examples/plain_ruby.rb
 - lib/event_trigger.rb
 - lib/event_trigger/configuration.rb
 - lib/event_trigger/defaults.rb
 - lib/event_trigger/dispatcher.rb
 - lib/event_trigger/event.rb
 - lib/event_trigger/provider.rb
+- lib/event_trigger/providers/discord_provider.rb
 - lib/event_trigger/providers/email_provider.rb
+- lib/event_trigger/providers/http_poster.rb
 - lib/event_trigger/providers/slack_provider.rb
 - lib/event_trigger/providers/webhook_provider.rb
+- lib/event_trigger/providers/whatsapp_provider.rb
 - lib/event_trigger/railtie.rb
 - lib/event_trigger/registry.rb
 - lib/event_trigger/version.rb