event_trigger 0.1.1 → 0.1.2

data/lib/event_trigger/providers/whatsapp_provider.rb

@@ -1,12 +1,8 @@
 # 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
+# NOTE: twilio-ruby is required lazily inside #deliver — see SmsProvider.
+# Keeping it out of load time means the gem pays nothing when WhatsApp
+# is disabled / unused (requirement: no eager provider deps).
 
 require_relative "../provider"
 
@@ -21,7 +17,7 @@ module EventTrigger
     #   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"]
+    #   config.whatsapp.events = ["payment.received", "loan.overdue"]
     #
     # Aliases: account_sid/sid, auth_token/token, from/to.
     # Per-trigger override: data: { whatsapp_to: "whatsapp:+..." }
@@ -37,8 +33,9 @@ module EventTrigger
       end
 
       def deliver(event)
-        unless defined?(Twilio::REST::Client)
-          raise Error, 'twilio-ruby gem is not installed (add `gem "twilio-ruby"` to your Gemfile)'
+        client_class = twilio_client_class
+        unless client_class
+          raise Error, TwilioClient::GEM_MISSING_MESSAGE
         end
 
         sid = config.twilio_sid || config.account_sid || config.sid
@@ -52,7 +49,7 @@ module EventTrigger
         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 = TwilioClient.resolve.new(sid.to_s, token.to_s)
         client.messages.create(
           from: normalize_number(from),
           to: normalize_number(to),
@@ -62,8 +59,15 @@ module EventTrigger
         true
       end
 
+
       private
 
+      # Thin wrapper around the lazy resolver — kept as an instance method
+      # so tests can stub it (e.g. simulate "gem missing" deterministically).
+      def twilio_client_class
+        TwilioClient.resolve
+      end
+
       def build_body(event)
         payload = event.payload
         err = payload[:error] || payload["error"]

data/lib/event_trigger/railtie.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+# Explicit: FileUtils is used by the initializer bootstrap below.
+# Must never raise at require time.
+begin
+  require "fileutils"
+rescue LoadError
+  nil
+end
+
 module EventTrigger
   # Rails integration:
   # 1. Applies safe defaults as soon as the gem is bundled (so the app
@@ -12,31 +20,42 @@ module EventTrigger
   #
   # Order: Railtie initializer runs BEFORE the host app's initializers, so
   # anything in config/initializers/event_trigger.rb wins over these defaults.
+  #
+  # Boot safety: every hook is wrapped so a failure here can never stop
+  # the host application from booting.
   if defined?(Rails::Railtie)
     class Railtie < Rails::Railtie
       generators do
         require "generators/event_trigger/install_generator" if defined?(Rails::Generators)
-      rescue LoadError
+      rescue StandardError
         nil
       end
 
       initializer "event_trigger.configure_rails_defaults", before: :load_environment_config do
-        require "event_trigger" unless defined?(EventTrigger::Dispatcher)
-        EventTrigger.apply_defaults!
-        if defined?(Rails.logger) && Rails.logger && EventTrigger.configuration.logger.nil?
-          EventTrigger.configuration.logger = Rails.logger
+        begin
+          require "event_trigger" unless defined?(EventTrigger::Dispatcher)
+          EventTrigger.apply_defaults!
+          if defined?(Rails.logger) && Rails.logger && EventTrigger.configuration.logger.nil?
+            EventTrigger.configuration.logger = Rails.logger
+          end
+        rescue StandardError => e
+          # Never break app boot because of notification defaults.
+          begin
+            Rails.logger&.warn("[EventTrigger] defaults could not be applied: #{e.class}: #{e.message}")
+          rescue StandardError
+            nil
+          end
         end
       end
 
       # Runs after app initializers are loaded: if the app has no
       # initializer of its own, write the default one so it exists on
-      # disk for the user to edit. Runs in every env except test (to
-      # keep the test suite hermetic).
+      # disk for the user to edit. Skipped in test to keep suites hermetic.
       initializer "event_trigger.ensure_initializer_present", after: :load_environment do
-        next unless defined?(Rails.root) && Rails.root
-        next if Rails.env.test? rescue nil
-
         begin
+          next unless defined?(Rails.root) && Rails.root
+          next if defined?(Rails.env) && Rails.env.test?
+
           dest = Rails.root.join("config/initializers/event_trigger.rb")
           next if File.exist?(dest)
 

data/lib/event_trigger/registry.rb

@@ -9,22 +9,30 @@ module EventTrigger
 
     class << self
       def register(name, klass)
-        @providers[name.to_sym] = klass
+        EventTrigger.lock.synchronize { @providers[name.to_sym] = klass }
+      rescue StandardError
+        nil
       end
 
       def fetch(name)
         @providers[name.to_sym]
+      rescue StandardError
+        nil
       end
 
       def all
         @providers.dup
+      rescue StandardError
+        {}
       end
 
       def registered?(name)
         @providers.key?(name.to_sym)
+      rescue StandardError
+        false
       end
 
-      # Restore the five built-in providers (used by reset!).
+      # Restore the eight built-in providers (used by reset!).
       def reset!
         @providers = {}
         require_relative "providers/slack_provider"
@@ -32,11 +40,17 @@ module EventTrigger
         require_relative "providers/webhook_provider"
         require_relative "providers/discord_provider"
         require_relative "providers/whatsapp_provider"
+        require_relative "providers/telegram_provider"
+        require_relative "providers/teams_provider"
+        require_relative "providers/sms_provider"
         register(:slack, Providers::SlackProvider)
         register(:email, Providers::EmailProvider)
         register(:webhook, Providers::WebhookProvider)
         register(:discord, Providers::DiscordProvider)
         register(:whatsapp, Providers::WhatsappProvider)
+        register(:telegram, Providers::TelegramProvider)
+        register(:teams, Providers::TeamsProvider)
+        register(:sms, Providers::SmsProvider)
       end
     end
   end

data/lib/event_trigger/threading.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module EventTrigger
+  # Reentrant lock shared by the provider registry, configuration and
+  # handler store (Monitor, not Mutex, so a callback may re-enter).
+  #
+  # Defined in its own file so it is available BEFORE registry.rb runs its
+  # load-time registration (otherwise built-in providers would silently
+  # fail to register at require time).
+  def self.lock
+    @lock ||= Monitor.new
+  rescue StandardError
+    # Extremely defensive: never let locking break loading.
+    Monitor.new
+  end
+end

data/lib/event_trigger/version.rb

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

data/lib/event_trigger.rb

@@ -1,15 +1,21 @@
 # frozen_string_literal: true
 
+require "monitor"
 require_relative "event_trigger/version"
+require_relative "event_trigger/threading"
 require_relative "event_trigger/configuration"
 require_relative "event_trigger/event"
 require_relative "event_trigger/registry"
 require_relative "event_trigger/provider"
+require_relative "event_trigger/providers/twilio_client"
 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/providers/telegram_provider"
+require_relative "event_trigger/providers/teams_provider"
+require_relative "event_trigger/providers/sms_provider"
 require_relative "event_trigger/dispatcher"
 require_relative "event_trigger/defaults"
 require_relative "event_trigger/railtie" if defined?(Rails::Railtie)
@@ -30,16 +36,24 @@ module EventTrigger
     end
 
     # Access (and memoize) the global configuration object.
+    # Never raises: returns a fresh Configuration if anything goes wrong.
     def configuration
+      @configuration || EventTrigger.lock.synchronize { @configuration ||= Configuration.new }
+    rescue StandardError
       @configuration ||= Configuration.new
     end
 
     # Reset configuration + handlers + provider registry to defaults.
-    # Primarily useful for tests.
+    # Primarily useful for tests. Never raises.
     def reset!
-      @configuration = Configuration.new
-      @handlers = Hash.new { |h, k| h[k] = [] }
-      Registry.reset!
+      EventTrigger.lock.synchronize do
+        @configuration = Configuration.new
+        @handlers = Hash.new { |h, k| h[k] = [] }
+        @last_result = nil
+        Registry.reset!
+      end
+    rescue StandardError
+      nil
     end
 
     # Register a handler block for a specific event name:
@@ -53,16 +67,18 @@ module EventTrigger
       raise ArgumentError, "EventTrigger.on requires a block" unless block_given?
 
       key = normalize_event_name(event_name)
-      handlers[key] << block
+      EventTrigger.lock.synchronize { handlers[key] << block }
       block
     end
 
     # Remove all handlers for an event (or all events when no name given).
     def off(event_name = nil)
-      if event_name.nil?
-        @handlers = Hash.new { |h, k| h[k] = [] }
-      else
-        handlers.delete(normalize_event_name(event_name))
+      EventTrigger.lock.synchronize do
+        if event_name.nil?
+          @handlers = Hash.new { |h, k| h[k] = [] }
+        else
+          handlers.delete(normalize_event_name(event_name))
+        end
       end
     end
 
@@ -85,21 +101,67 @@ module EventTrigger
     #
     # Builds an EventTrigger::Event and hands it to the Dispatcher,
     # which fans out to every enabled provider configured for that event.
-    # Returns the Event object.
+    # Returns the Event object (unchanged). The provider-wise result hash
+    # ({ event:, status:, providers: {...} }) is available as
+    # EventTrigger.last_result and as event.last_result.
+    #
+    # NEVER RAISES: any unexpected internal error is logged and captured
+    # in the result (status: "error") so the host app can never be harmed
+    # by this gem.
     def trigger(event_name, data: {})
-      event = Event.new(name: normalize_event_name(event_name), payload: data || {})
-      Dispatcher.new(configuration).dispatch(event, handlers_for(event.name))
+      event = build_event(event_name, data)
+      begin
+        result = Dispatcher.new(configuration).dispatch(event, handlers_for(event.name))
+      rescue StandardError => e
+        result = { event: event.name, status: "error", error: "#{e.class}: #{e.message}", providers: {} }
+        safe_log("#{e.class}: #{e.message}")
+      end
+      @last_result = result
+      event.last_result = result
       event
     end
 
+    # Provider-wise result of the most recent trigger call, e.g.:
+    #   { event: "loan.activated", status: "success",
+    #     providers: { slack: "sent", email: "sent", discord: "skipped (disabled)", ... } }
+    # Nil until the first trigger call.
+    def last_result
+      @last_result
+    end
+
     # Handlers registered for a given event name (string).
+    # Uses #fetch so unknown event names don't grow the handler table.
     def handlers_for(event_name)
-      handlers[normalize_event_name(event_name)].dup
+      EventTrigger.lock.synchronize { handlers.fetch(normalize_event_name(event_name), []).dup }
+    rescue StandardError
+      []
     end
 
     # Normalize event names to strings ("loan.activated").
     def normalize_event_name(name)
       name.to_s
+    rescue StandardError
+      ""
+    end
+
+    private
+
+    # Builds the Event defensively: even a pathological payload (odd keys,
+    # objects whose #to_s raises, non-hash data) cannot raise here.
+    def build_event(event_name, data)
+      Event.new(name: normalize_event_name(event_name), payload: data || {})
+    rescue StandardError
+      Event.new(name: "", payload: {})
+    end
+
+    # Logging must never raise into the host app.
+    def safe_log(message)
+      logger = configuration.logger
+      return unless logger.respond_to?(:info)
+
+      logger.info("[EventTrigger] #{message}")
+    rescue StandardError
+      nil
     end
   end
 end

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

@@ -19,11 +19,33 @@ EventTrigger.configure do |config|
   config.email.enabled = false
   config.email.from = ENV["EVENT_TRIGGER_EMAIL_FROM"]
   config.email.to = ENV["EVENT_TRIGGER_EMAIL_TO"]
+  # Rails apps: uncomment so delivery goes through ActionMailer
+  # (which uses config.action_mailer.smtp_settings below).
+  # config.email.delivery_method = :action_mailer
   # nil (or []) = ALL events.
   config.email.events = ["loan.activated", "loan.foreclosed"]
 
+  # --- ActionMailer SMTP (Rails) ---
+  # Uncomment and move these lines to config/environments/development.rb
+  # (and production.rb). Requires `gem "net-smtp"` on Ruby 3.1+.
+  # config.action_mailer.delivery_method = :smtp
+  # config.action_mailer.smtp_settings = {
+  #   address: ENV.fetch("SMTP_ADDRESS", "smtp.gmail.com"),
+  #   port: ENV.fetch("SMTP_PORT", "587").to_i,
+  #   domain: ENV.fetch("SMTP_DOMAIN", "gmail.com"),
+  #   user_name: ENV["SMTP_USERNAME"],
+  #   password: ENV["SMTP_PASSWORD"]&.delete(" "),
+  #   authentication: :plain,
+  #   enable_starttls_auto: true
+  # }
+  # .env entries needed:
+  # SMTP_USERNAME=youremail@gmail.com
+  # SMTP_PASSWORD=xxxx xxxx xxxx xxxx   # Gmail App Password (16 letters), not your login password
+
   config.webhook.enabled = false
   config.webhook.url = ENV["EVENT_TRIGGER_WEBHOOK_URL"]
+  # NOTE: `method` collides with Ruby's Object#method, so set it via []:
+  # config.webhook[:method] = :post   # :post (default) | :put | :patch | :delete | :get
   # nil (or []) = ALL events.
   config.webhook.events = ["loan.activated"]
 
@@ -39,4 +61,26 @@ EventTrigger.configure do |config|
   config.whatsapp.twilio_to = ENV["TWILIO_WHATSAPP_TO"]
   # nil (or []) = ALL events.
   config.whatsapp.events = []
+
+  # --- NEW providers (opt-in; all default to disabled) ---
+  config.telegram.enabled = false
+  config.telegram.bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+  config.telegram.chat_id = ENV["TELEGRAM_CHAT_ID"]
+  # nil (or []) = ALL events.
+  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"]
+  # nil (or []) = ALL events.
+  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"]
+  # nil (or []) = ALL events.
+  config.sms.events = []
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_trigger
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Kamlesh Parmar
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -133,10 +133,15 @@ files:
 - 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/sms_provider.rb
+- lib/event_trigger/providers/teams_provider.rb
+- lib/event_trigger/providers/telegram_provider.rb
+- lib/event_trigger/providers/twilio_client.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/threading.rb
 - lib/event_trigger/version.rb
 - lib/generators/event_trigger/install_generator.rb
 - lib/generators/event_trigger/templates/event_trigger.rb