active_webhook 1.0.0

data/lib/active_webhook/delivery/base_adapter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Delivery
+    class BaseAdapter < Adapter
+      attribute :subscription, :hook, :max_errors_per_hour
+      attr_accessor :response
+
+      delegate :url, :headers, :body, to: :hook
+
+      def max_errors_per_hour
+        @max_errors_per_hour.nil? ? component_configuration.max_errors_per_hour : @max_errors_per_hour
+      end
+
+      def call
+        ensure_error_log_requirement_is_met!
+
+        wrap_with_log do
+          self.response = deliver!
+
+          case status_code
+          when 200
+            trace "Completed"
+          when 410
+            trace "Receieved HTTP response code [410] for"
+            subscription.destroy!
+          else
+            raise response.to_s
+          end
+        end
+      rescue StandardError => e
+        subscription.error_logs.create!
+
+        raise e # propogate error so queuing adapter has a chance to retry
+      end
+
+      def status_code
+        raise NotImplementedError, "#deliver! must be implemented."
+      end
+
+      def topic
+        subscription.topic
+      end
+
+      protected
+
+      def self.component_name
+        "delivery"
+      end
+
+      def deliver!
+        raise NotImplementedError, "#deliver! must be implemented."
+      end
+
+      def ensure_error_log_requirement_is_met!
+        if subscription.ensure_error_log_requirement_is_met! max_errors_per_hour
+          trace "Disabled"
+        end
+      end
+
+      def wrap_with_log
+        return if ActiveWebhook.disabled?
+
+        trace("Skipped [subscription disabled]") and return if subscription.disabled?
+        trace("Skipped [topic disabled]") and return if topic.disabled?
+        trace "Initiated"
+        trace "Payload [#{hook.to_h.ai}] for", :debug if ActiveWebhook.logger.level == 0 # log_payloads
+
+        yield
+
+        trace "Completed"
+
+        true
+      rescue StandardError => e
+        trace "Failed to complete [#{e.message}]", :error
+
+        raise e # propogate error so queuing adapter has a chance to retry
+      end
+
+      def trace(msg, level = :info)
+        ActiveWebhook.logger.send(level, decorate_log_msg(msg))
+
+        true
+      end
+
+      def decorate_log_msg(msg)
+        [
+          msg,
+          "active webhook subscription #{subscription.id}",
+          "with(key: #{topic.key}, version: #{topic.version})",
+          "to url: #{hook.url} via #{self.class.name}"
+        ].join(' ')
+      end
+    end
+  end
+end

data/lib/active_webhook/delivery/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Delivery
+    class Configuration
+      include ActiveWebhook::Configuration::Base
+
+      define_option :adapter,
+                    values: %i[net_http faraday],
+                    allow_proc: true
+
+      define_option :max_errors_per_hour,
+                    default: 100
+    end
+  end
+end

data/lib/active_webhook/delivery/faraday_adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module ActiveWebhook
+  module Delivery
+    class FaradayAdapter < BaseAdapter
+      def status_code
+        response.status
+      end
+
+      protected
+
+      def deliver!
+        Faraday.post(url, body, headers)
+      end
+    end
+  end
+end

data/lib/active_webhook/delivery/net_http_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+
+module ActiveWebhook
+  module Delivery
+    class NetHTTPAdapter < BaseAdapter
+      def status_code
+        response.code.to_i
+      end
+
+      protected
+
+      def deliver!
+        uri = URI.parse(url.strip)
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.body = body
+        headers.each { |k, v| request[k] = v }
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme.casecmp("https").zero?
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/active_webhook/error_log.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  class ErrorLog < ActiveRecord::Base
+    include ActiveWebhook::Models::ErrorLogAdditions
+  end
+end

data/lib/active_webhook/formatting/base_adapter.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Formatting
+    class BaseAdapter < Adapter
+      attribute :subscription, :job_id, :type
+
+      def call
+        Hook.new url, headers, body
+      end
+
+      protected
+
+      def self.component_name
+        "formatting"
+      end
+
+      def url
+        subscription.callback_url
+      end
+
+      def headers
+        default_headers.stringify_keys.merge(custom_headers.transform_keys { |key| "#{prefix}-#{key}" })
+      end
+
+      def body
+        encoded_data
+      end
+
+      def encoded_data
+        raise NotImplementedError, "#encoded_data must be implemented."
+      end
+
+      def content_type
+        raise NotImplementedError, "#content_type must be implemented."
+      end
+
+      def default_headers
+        h = {
+          "Content-Type": content_type,
+          "User-Agent": component_configuration.user_agent
+        }
+        h['Origin'] = ActiveWebhook.origin.to_s if ActiveWebhook.origin.present?
+        h
+      end
+
+      def custom_headers
+        h = signature_headers.merge(
+          Time: time.to_s,
+          Topic: topic.key,
+          'Topic-Version': topic.version,
+          'Webhook-Type': type.presence || "event"
+        )
+        h['Webhook-Id'] = job_id if job_id.present?
+        h
+      end
+
+      def data
+        context[:data].presence || resource&.as_json || default_data
+      end
+
+      def default_data
+        result = { data: {} }
+
+        if resource_id || resource_type
+          result[:data] = {}
+          result[:data][:id] = resource_id if resource_id
+          result[:data][:type] = resource_type if resource_type
+        end
+
+        result
+      end
+
+      def resource_id
+        context[:resource_id]
+      end
+
+      def resource_type
+        context[:resource_type]
+      end
+
+      def resource
+        resource_type.constantize.find_by(id: resource_id) if type == "resource" && resource_id && resource_type
+      rescue StandardError
+        nil
+      end
+
+      def topic
+        subscription.topic
+      end
+
+      def prefix
+        @prefix ||= begin
+          x = ["X"]
+          x << component_configuration.custom_header_prefix
+          x.compact.join("-")
+        end
+      end
+
+      def time
+        context[:time] || Time.current
+      end
+
+      def signature_headers
+        ActiveWebhook.verification_adapter.call secret: subscription.shared_secret.to_s, data: body.to_s
+      end
+    end
+  end
+end

data/lib/active_webhook/formatting/configuration.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Formatting
+    class Configuration
+      include ActiveWebhook::Configuration::Base
+
+      define_option :adapter,
+                    values: %i[json url_encoded],
+                    allow_proc: true
+
+      define_option :custom_header_prefix
+
+      define_option :user_agent,
+                    default: ActiveWebhook::IDENTIFIER
+    end
+  end
+end

data/lib/active_webhook/formatting/json_adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ActiveWebhook
+  module Formatting
+    class JSONAdapter < BaseAdapter
+      protected
+
+      def content_type
+        "application/json"
+      end
+
+      def encoded_data
+        data.to_json
+      end
+    end
+  end
+end

data/lib/active_webhook/formatting/url_encoded_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "addressable/uri"
+
+module ActiveWebhook
+  module Formatting
+    class URLEncodedAdapter < BaseAdapter
+      protected
+
+      def self.compact(h)
+        h.delete_if { |k, v|
+          v = compact(v) if v.respond_to?(:each)
+          v.nil? || v.empty?
+        }
+      end
+
+      def content_type
+        "application/x-www-form-urlencoded"
+      end
+
+      def encoded_data
+        uri = Addressable::URI.new
+        uri.query_values = self.class.compact(data)
+        uri.query
+      end
+    end
+  end
+end

data/lib/active_webhook/hook.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  Hook = Struct.new :url, :headers, :body do
+    def self.from_h(url: '', headers: {}, body: "")
+      new url, headers, body
+    end
+  end
+end

data/lib/active_webhook/logger.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  class Logger
+    def info(msg)
+      puts msg
+    end
+
+    def debug(msg)
+      puts msg
+    end
+
+    def error(msg)
+      puts msg
+    end
+
+    def warn(msg)
+      puts msg
+    end
+  end
+end

data/lib/active_webhook/models/configuration.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Models
+    class Configuration
+      include ActiveWebhook::Configuration::Base
+
+      define_option :subscription,
+                    default: ActiveWebhook::Subscription
+
+      define_option :topic,
+                    default: ActiveWebhook::Topic
+
+      define_option :error_log,
+                    default: ActiveWebhook::ErrorLog
+    end
+  end
+end

data/lib/active_webhook/models/error_log_additions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Models
+    module ErrorLogAdditions
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = "active_webhook_error_logs"
+
+        validates_presence_of :subscription
+      end
+    end
+  end
+end

data/lib/active_webhook/models/subscription_additions.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Models
+    module SubscriptionAdditions
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = "active_webhook_subscriptions"
+
+        scope :enabled, -> { where(disabled_at: nil) }
+
+        validates_presence_of :topic
+        validates :callback_url, format: {
+          with: URI::DEFAULT_PARSER.make_regexp(['http', 'https']),
+          message: 'is not a valid URL'
+        }
+
+        before_save :set_disabled_reason
+        after_save :clean_error_log
+      end
+
+      def set_disabled_reason
+        self.disabled_reason = nil if self.disabled_at.nil?
+      end
+
+      def clean_error_log
+        error_logs.delete_all if previous_changes.key?(:disabled_at) && enabled?
+      end
+
+      def ensure_error_log_requirement_is_met! max_errors_per_hour
+        return false if disabled?
+
+        if max_errors_per_hour.present? && error_logs.where('created_at > ?', 1.hour.ago).count > max_errors_per_hour
+          disable! "Exceeded max_errors_per_hour of (#{max_errors_per_hour})"
+          return true
+        end
+      rescue StandardError
+        # intentionally squash errors so that we don't end up in a loop where queue adapter retries and locks table
+        false
+      end
+
+      def disable(reason = nil)
+        self.disabled_at = Time.current
+        self.disabled_reason = reason
+      end
+
+      def disable!(reason = nil)
+        disable reason
+        save!
+      end
+
+      def enable
+        self.disabled_at = nil
+        self.disabled_reason = nil
+      end
+
+      def enable!
+        enable
+        save!
+      end
+
+      def disabled?
+        !enabled?
+      end
+
+      def enabled?
+        disabled_at.nil?
+      end
+    end
+  end
+end