event_trigger 0.1.1 → 0.1.2

data/lib/event_trigger/providers/email_provider.rb

@@ -46,6 +46,7 @@ module EventTrigger
         true
       end
 
+
       private
 
       def action_mailer_delivery?
@@ -68,7 +69,24 @@ module EventTrigger
       def deliver_via_smtp(from, to, subject, body)
         require "net/smtp"
         settings = smtp_settings
-        message = <<~MSG
+        message = build_message(from, to, subject, body)
+        smtp = Net::SMTP.new(settings[:address] || "localhost", settings[:port] || 25)
+        apply_smtp_timeouts(smtp, settings)
+        if settings[:enable_starttls_auto] && smtp.respond_to?(:enable_starttls_auto)
+          smtp.enable_starttls_auto
+        end
+        smtp.start(
+          settings[:domain] || "localhost",
+          settings[:user_name] || settings[:username],
+          settings[:password],
+          settings[:authentication] || :plain
+        ) do
+          smtp.send_message(message, from, Array(to))
+        end
+      end
+
+      def build_message(from, to, subject, body)
+        <<~MSG
           From: #{from}
           To: #{Array(to).join(", ")}
           Subject: #{subject}
@@ -77,20 +95,29 @@ module EventTrigger
 
           #{body}
         MSG
-        Net::SMTP.start(
-          settings[:address] || "localhost",
-          settings[:port] || 25,
-          settings[:domain] || "localhost",
-          settings[:user_name],
-          settings[:password],
-          settings[:authentication] || :plain
-        ) do |smtp|
-          smtp.send_message(message, from, Array(to))
-        end
       end
 
+      # Guard against a stalled/unreachable SMTP server blocking the app
+      # forever (configurable via config.email.smtp timeouts).
+      def apply_smtp_timeouts(smtp, settings)
+        smtp.open_timeout = settings[:open_timeout] || 5 if smtp.respond_to?(:open_timeout=)
+        smtp.read_timeout = settings[:read_timeout] || 10 if smtp.respond_to?(:read_timeout=)
+        smtp.write_timeout = settings[:write_timeout] || 10 if smtp.respond_to?(:write_timeout=)
+      rescue StandardError
+        nil
+      end
+
+      # NEW additive alias: spec uses config.email.smtp = {...}.
+      # Existing config.email.smtp_settings keeps working; smtp wins
+      # when both are set. Accepts string or symbol keys.
       def smtp_settings
-        config.smtp_settings || {}
+        raw = config.smtp || config.smtp_settings || {}
+        raw = {} unless raw.is_a?(Hash)
+        raw.each_with_object({}) do |(k, v), memo|
+          key = k.to_sym
+          key = :user_name if key == :username # Net::SMTP expects :user_name
+          memo[key] = v
+        end
       end
 
       def build_subject(event)

data/lib/event_trigger/providers/http_poster.rb

@@ -12,6 +12,9 @@ module EventTrigger
     # 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).
+    #
+    # NOTE: faraday is loaded lazily (only on fallback) so apps that
+    # never hit the network path pay no load cost.
     module HttpPoster
       private
 
@@ -26,31 +29,73 @@ module EventTrigger
         end
       end
 
+      def request_json(method, url, body, headers = { "Content-Type" => "application/json" }, service: "HTTP")
+        payload = JSON.generate(body)
+        begin
+          net_http_request(method, url, payload, headers, service)
+        rescue EventTrigger::Error
+          raise
+        rescue StandardError => e
+          # Only POST has a Faraday fallback today; other verbs re-raise.
+          raise e unless method.to_s.downcase == "post"
+
+          faraday_post(url, payload, headers, service, e)
+        end
+      end
+
       def net_http_post(url, payload, headers, service)
+        net_http_request(:post, url, payload, headers, service)
+      end
+
+      def net_http_request(method, url, payload, headers, service)
         uri = URI.parse(url.to_s)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = uri.scheme == "https"
+        # Hard timeouts at both ends: connect, read AND write. Without these
+        # a stalled peer could block the host app's web worker indefinitely.
         http.open_timeout = 5
         http.read_timeout = 10
-        request = Net::HTTP::Post.new(uri.request_uri, headers)
-        request.body = payload
+        http.write_timeout = 10 if http.respond_to?(:write_timeout=)
+        http.continue_timeout = 5 if http.respond_to?(:continue_timeout=)
+        klass = case method.to_s.downcase
+                when "get" then Net::HTTP::Get
+                when "put" then Net::HTTP::Put
+                when "patch" then Net::HTTP::Patch
+                when "delete" then Net::HTTP::Delete
+                else Net::HTTP::Post
+                end
+        request = klass.new(uri.request_uri, headers)
+        request.body = payload unless method.to_s.downcase == "get"
         response = http.request(request)
         unless response.is_a?(Net::HTTPSuccess)
-          raise Error, "#{service} delivery failed (HTTP #{response.code}): #{response.body}"
+          raise Error, "#{service} delivery failed (HTTP #{response.code}): #{truncate(response.body)}"
         end
         response
       end
 
       def faraday_post(url, payload, headers, service, original_error)
         require "faraday"
-        response = Faraday.post(url.to_s, payload, headers)
+        conn = Faraday.new do |f|
+          f.options.timeout = 10
+          f.options.open_timeout = 5
+        end
+        response = conn.post(url.to_s, payload, headers)
         unless response.success?
-          raise Error, "#{service} delivery failed (HTTP #{response.status}): #{response.body}"
+          raise Error, "#{service} delivery failed (HTTP #{response.status}): #{truncate(response.body)}"
         end
         response
       rescue LoadError
         raise original_error
       end
+
+      # Keep error messages bounded — a huge HTML error page must not blow
+      # up memory or logs.
+      def truncate(str, limit = 500)
+        s = str.to_s
+        s.length > limit ? "#{s[0, limit]}…" : s
+      rescue StandardError
+        ""
+      end
     end
   end
 end

data/lib/event_trigger/providers/slack_provider.rb

@@ -5,41 +5,86 @@ require "uri"
 require "json"
 require "time"
 require_relative "../provider"
+require_relative "http_poster"
 
 module EventTrigger
   module Providers
-    # Sends event notifications to Slack (or any Slack-compatible /
-    # Discord-compatible incoming-webhook URL).
+    # Sends event notifications to Slack.
     #
-    # Config:
-    #   config.slack.enabled = true
-    #   config.slack.webhook_url = ENV["SLACK_WEBHOOK_URL"]
-    #   config.slack.events = ["loan.activated"]
+    # Two modes (existing webhook mode is untouched):
+    #
+    # 1. Legacy incoming-webhook mode (unchanged):
+    #      config.slack.webhook_url = ENV["SLACK_WEBHOOK_URL"]
+    #    - hooks.slack.com URLs receive { text: ... }.
+    #    - any other URL receives the Discord-style embed payload.
+    #
+    # 2. NEW Slack Web API mode (chat.postMessage), used only when BOTH
+    #    token + channel are set:
+    #      config.slack.token = ENV["SLACK_BOT_TOKEN"]
+    #      config.slack.channel = ENV["SLACK_CHANNEL"]  # e.g. "#alerts" or "C123"
+    #      API: POST https://slack.com/api/chat.postMessage
+    #      Auth: Authorization: Bearer <token>
     #
-    # Payload behaviour:
-    # - Slack incoming webhooks (hooks.slack.com) receive { text: ... }.
-    # - All other URLs (e.g. Discord-style webhooks) receive a rich embed
-    #   payload with error/backtrace/context fields, truncated to stay
-    #   within message limits.
+    # Common:
+    #   config.slack.enabled = true
+    #   config.slack.events = ["loan.activated", "payment.received"]
     class SlackProvider < Provider
       MAX_TEXT = 1500
 
+      WEB_API_URL = "https://slack.com/api/chat.postMessage"
+
       def self.provider_name
         :slack
       end
 
+      include HttpPoster
+
       def deliver(event)
+        # --- NEW: Web API mode (additive; webhook path below untouched) ---
+        token = config.token
+        channel = config.channel
+        if present?(token) && present?(channel)
+          return deliver_via_web_api(event, token.to_s, channel.to_s)
+        end
+
+        # --- Existing webhook mode (byte-for-byte behaviour preserved) ---
         url = config.webhook_url || config.url
         raise Error, "Slack webhook_url is not configured" if url.nil? || url.to_s.strip.empty?
 
         body = build_payload(url.to_s, event)
-        post_json(url.to_s, body)
+        post_json(url.to_s, body, { "Content-Type" => "application/json" }, service: "Slack")
         log("delivered event '#{event.name}'")
         true
       end
 
+
       private
 
+      def deliver_via_web_api(event, token, channel)
+        body = { channel: channel, text: slack_text(event, event.payload) }
+        response = post_json(
+          WEB_API_URL, body,
+          { "Content-Type" => "application/json", "Authorization" => "Bearer #{token}" },
+          service: "Slack"
+        )
+        parsed = parse_json(response.body)
+        unless parsed.is_a?(Hash) && parsed["ok"] == true
+          raise Error, "Slack Web API error: #{response.body}"
+        end
+        log("delivered event '#{event.name}' via chat.postMessage")
+        true
+      end
+
+      def parse_json(str)
+        JSON.parse(str.to_s)
+      rescue StandardError
+        nil
+      end
+
+      def present?(value)
+        !value.nil? && !value.to_s.strip.empty?
+      end
+
       def build_payload(url, event)
         payload = event.payload
         if url.include?("hooks.slack.com")
@@ -103,21 +148,6 @@ module EventTrigger
       def truncate_for_discord(str, limit = 1000)
         truncate(str, limit)
       end
-
-      def post_json(url, body)
-        uri = URI.parse(url)
-        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, "Content-Type" => "application/json")
-        request.body = JSON.generate(body)
-        response = http.request(request)
-        unless response.is_a?(Net::HTTPSuccess)
-          raise Error, "Slack delivery failed (HTTP #{response.code}): #{response.body}"
-        end
-        response
-      end
     end
   end
 end

data/lib/event_trigger/providers/sms_provider.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+
+module EventTrigger
+  module Providers
+    # Sends SMS notifications. Pluggable interface — today backed by
+    # Twilio (lazy-loaded, only when this provider is enabled/used).
+    #
+    #   Twilio Messaging API base: https://api.twilio.com/2010-04-01
+    #
+    # Config:
+    #   config.sms.enabled = true
+    #   config.sms.provider = :twilio            # only :twilio supported today
+    #   config.sms.account_sid = ENV["TWILIO_ACCOUNT_SID"]
+    #   config.sms.auth_token = ENV["TWILIO_AUTH_TOKEN"]
+    #   config.sms.from = ENV["TWILIO_FROM"]     # E.164 number, e.g. +15551234567
+    #   config.sms.events = ["payment.received"]
+    #
+    # Per-trigger overrides: data: { sms_to:, sms_body: }
+    # Crash-safe: failures raise EventTrigger::Error (Dispatcher logs them).
+    class SmsProvider < Provider
+      MAX_BODY = 1000
+
+      def self.provider_name
+        :sms
+      end
+
+      def deliver(event)
+        name = (config.provider || :twilio).to_sym
+        raise Error, "SMS provider #{name.inspect} is not supported (only :twilio)" unless name == :twilio
+
+        client_class = twilio_client_class
+        unless client_class
+          raise Error, TwilioClient::GEM_MISSING_MESSAGE
+        end
+
+        sid = config.account_sid || config.twilio_sid
+        token = config.auth_token || config.twilio_token
+        from = config.from || config.twilio_from
+        to = event.payload[:sms_to] || event.payload["sms_to"] || config.to
+        raise Error, "SMS account_sid is not configured" if blank?(sid)
+        raise Error, "SMS auth_token is not configured" if blank?(token)
+        raise Error, "SMS sender (from) is not configured" if blank?(from)
+        raise Error, "SMS recipient (to) is not configured" if blank?(to)
+
+        body = event.payload[:sms_body] || event.payload["sms_body"] || build_body(event)
+        Twilio::REST::Client.new(sid.to_s, token.to_s).messages.create(
+          from: from.to_s, to: to.to_s, body: truncate(body.to_s)
+        )
+        log("delivered event '#{event.name}' to #{to}")
+        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)
+        err = event.payload[:error] || event.payload["error"]
+        return err.to_s if err
+
+        summary = event.payload.map { |k, v| "#{k}: #{v}" }.join(", ")
+        summary = event.payload.inspect if summary.empty?
+        "[#{event.name}] #{summary}"
+      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/providers/teams_provider.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+require_relative "http_poster"
+
+module EventTrigger
+  module Providers
+    # Sends event notifications to a Microsoft Teams channel via the
+    # Microsoft Graph API.
+    #
+    #   API: POST https://graph.microsoft.com/v1.0/teams/{team-id}/channels/{channel-id}/messages
+    #   Auth: Authorization: Bearer <ACCESS_TOKEN>
+    #
+    # Config:
+    #   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.teams.events = ["loan.activated"]
+    #
+    # Crash-safe: failures raise EventTrigger::Error (Dispatcher logs them).
+    class TeamsProvider < Provider
+      include HttpPoster
+
+      GRAPH_BASE = "https://graph.microsoft.com/v1.0"
+
+      def self.provider_name
+        :teams
+      end
+
+      def deliver(event)
+        token = config.access_token
+        team_id = config.team_id
+        channel_id = config.channel_id
+        raise Error, "Teams access_token is not configured" if blank?(token)
+        raise Error, "Teams team_id is not configured" if blank?(team_id)
+        raise Error, "Teams channel_id is not configured" if blank?(channel_id)
+
+        url = "#{GRAPH_BASE}/teams/#{team_id}/channels/#{channel_id}/messages"
+        post_json(
+          url, { body: { contentType: "text", content: message_text(event) } },
+          { "Content-Type" => "application/json", "Authorization" => "Bearer #{token}" },
+          service: "Teams"
+        )
+        log("delivered event '#{event.name}'")
+        true
+      end
+
+
+      private
+
+      def message_text(event)
+        payload = event.payload
+        err = payload[:error] || payload["error"]
+        return err.to_s if err
+
+        summary = payload.map { |k, v| "#{k}: #{v}" }.join(", ")
+        summary = payload.inspect if summary.empty?
+        "[#{event.name}] #{summary}"
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end

data/lib/event_trigger/providers/telegram_provider.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+require_relative "http_poster"
+
+module EventTrigger
+  module Providers
+    # Sends event notifications to Telegram via the Bot API.
+    #
+    #   API: POST https://api.telegram.org/bot<BOT_TOKEN>/sendMessage
+    #
+    # Config:
+    #   config.telegram.enabled = true
+    #   config.telegram.bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+    #   config.telegram.chat_id = ENV["TELEGRAM_CHAT_ID"]
+    #   config.telegram.events = ["loan.overdue"]
+    #
+    # Per-trigger override: data: { telegram_chat_id: "..." }
+    # Crash-safe: failures raise EventTrigger::Error (Dispatcher logs them).
+    class TelegramProvider < Provider
+      include HttpPoster
+
+      MAX_TEXT = 4000
+
+      def self.provider_name
+        :telegram
+      end
+
+      def deliver(event)
+        token = config.bot_token
+        chat_id = event.payload[:telegram_chat_id] || event.payload["telegram_chat_id"] || config.chat_id
+        raise Error, "Telegram bot_token is not configured" if blank?(token)
+        raise Error, "Telegram chat_id is not configured" if blank?(chat_id)
+
+        url = "https://api.telegram.org/bot#{token}/sendMessage"
+        response = post_json(url, { chat_id: chat_id.to_s, text: message_text(event) }, service: "Telegram")
+        parsed = parse_json(response_body(response))
+        # Telegram returns { "ok": true, ... } on success.
+        if parsed.is_a?(Hash) && parsed.key?("ok") && parsed["ok"] != true
+          raise Error, "Telegram delivery failed: #{response_body(response)}"
+        end
+        log("delivered event '#{event.name}'")
+        true
+      end
+
+
+      private
+
+      def message_text(event)
+        payload = event.payload
+        err = payload[:error] || payload["error"]
+        text =
+          if err
+            bt = payload[:backtrace] || payload["backtrace"]
+            lines = ["🚨 #{err}"]
+            lines << Array(bt).first.to_s if bt
+            lines.join("\n")
+          else
+            summary = payload.map { |k, v| "#{k}: #{v}" }.join(", ")
+            summary = payload.inspect if summary.empty?
+            "[#{event.name}] #{summary}"
+          end
+        truncate(text)
+      end
+
+      def response_body(response)
+        response.respond_to?(:body) ? response.body : response.to_s
+      end
+
+      def parse_json(str)
+        require "json"
+        JSON.parse(str.to_s)
+      rescue StandardError
+        nil
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def truncate(str, limit = MAX_TEXT)
+        s = str.to_s
+        s.length > limit ? "#{s[0, limit]}…" : s
+      end
+    end
+  end
+end

data/lib/event_trigger/providers/twilio_client.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EventTrigger
+  module Providers
+    # Lazy, crash-safe resolver for the Twilio client class.
+    #
+    # - Returns the already-loaded (or test-stubbed) client when present,
+    #   so `twilio-ruby` is never loaded until a Twilio-backed provider
+    #   (SMS / WhatsApp) is actually used.
+    # - Requires the gem on demand on first use.
+    # - Raises EventTrigger::Error (never LoadError/NameError) when the
+    #   gem is missing or broken, so the Dispatcher can log it and the
+    #   host app keeps running.
+    module TwilioClient
+      GEM_MISSING_MESSAGE =
+        'twilio-ruby gem is not installed (add `gem "twilio-ruby"` to your Gemfile)'.freeze
+
+      def self.resolve
+        klass = loaded_client
+        return klass if klass
+
+        begin
+          require "twilio-ruby"
+        rescue LoadError, StandardError => e
+          raise Error, "#{GEM_MISSING_MESSAGE} (#{e.class}: #{e.message})"
+        end
+        loaded_client || raise(Error, GEM_MISSING_MESSAGE)
+      end
+
+      # Explicit Object-space lookup (instead of lexical `defined?`) so
+      # test doubles (stub_const / hide_const) behave predictably.
+      def self.loaded_client
+        return nil unless ::Object.const_defined?(:Twilio)
+
+        rest = ::Twilio.const_defined?(:REST, false) ? ::Twilio::REST : nil
+        return nil unless rest
+        return nil unless rest.const_defined?(:Client, false)
+
+        rest.const_get(:Client, false)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/event_trigger/providers/webhook_provider.rb

@@ -4,17 +4,28 @@ require "net/http"
 require "uri"
 require "json"
 require_relative "../provider"
+require_relative "http_poster"
 
 module EventTrigger
   module Providers
-    # POSTs the event as JSON to a configured HTTP endpoint.
+    # Generic HTTP webhook provider for any custom system.
     #
-    # Config:
-    #   config.webhook.enabled = true
-    #   config.webhook.url = "https://example.com/hooks/events"
+    # Existing behaviour (unchanged): POSTs { event:, payload:,
+    # timestamp: } as JSON to config.webhook.url with optional
+    # config.webhook.headers.
+    #
+    # NEW additive options (only used when set):
+    #   config.webhook.method = :post        # :post (default), :put, :patch, :delete, :get
+    # NOTE: ProviderConfig defines Object#method, so write the verb via
+    # `config.webhook[:method] = :post` (reader also via config[:method]).
+    #   config.webhook.url = ENV["EVENT_WEBHOOK_URL"]
     #   config.webhook.headers = { "Authorization" => "Bearer ..." }
-    #   config.webhook.events = ["loan.activated"]
+    #
+    # method is normalized (:POST/"post" all work); unknown verbs fall back
+    # to POST so old configs never break.
     class WebhookProvider < Provider
+      include HttpPoster
+
       def self.provider_name
         :webhook
       end
@@ -23,13 +34,19 @@ module EventTrigger
         url = config.url
         raise Error, "Webhook url is not configured" if url.nil? || url.to_s.strip.empty?
 
-        post_json(url.to_s, event_to_json(event), headers)
+        request_json(http_method, url.to_s, event_to_json(event), headers, service: "Webhook")
         log("delivered event '#{event.name}' to #{url}")
         true
       end
 
+
       private
 
+      def http_method
+        m = ((config[:method] rescue nil) || :post).to_s.downcase
+        %w[get post put patch delete].include?(m) ? m.to_sym : :post
+      end
+
       def headers
         { "Content-Type" => "application/json" }.merge(config.headers || {})
       end
@@ -45,21 +62,6 @@ module EventTrigger
       def stringify(hash)
         hash.each_with_object({}) { |(k, v), m| m[k.to_s] = v }
       end
-
-      def post_json(url, body, headers)
-        uri = URI.parse(url)
-        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 = JSON.generate(body)
-        response = http.request(request)
-        unless response.is_a?(Net::HTTPSuccess)
-          raise Error, "Webhook delivery failed (HTTP #{response.code}): #{response.body}"
-        end
-        response
-      end
     end
   end
 end