slack_bot-events 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e221d5ba2b7822f18b4079b73bc35005488510570b1c6bf1121b29ae3a38a85f
-  data.tar.gz: 7c6fd667337ad3eaefc080abac2d53295b6226c41570dcebc118eb321e218a0b
+  metadata.gz: 653594899c76b05d93054ceb20520d84a487a38451ecee7d561ab5b9e6590bf7
+  data.tar.gz: 3f722375d06dce4ca2a3f4151ed221948b9e1d5e6d87842cf966ff067c54c31b
 SHA512:
-  metadata.gz: 9545811f097ea137483b27bfd4b93cfb9d64040487051fd9f906de4d67e09503768fa4341faad9eed36348edf644ad33be7f9109f3c5a9d5741d59fc9c8ca17b
-  data.tar.gz: 2afc096dd076de82f0f3443a7ac437be405f6b8613db994072a94cb05623797cc631b178e163c756ddfbd7f2c29e337bbb42db5fe71e42aed0b5b148c3bfd5ea
+  metadata.gz: eb0fb66fded40a580f042bd45e9ba139cf3753d2960461265d07394a5c182a35c9f35d33105e7ca5536b6e279c44335baf6b8ba645e531186ffbf3c4d9790dcc
+  data.tar.gz: 02f478db61cabfce5f8e66b7303f47f9ed548d08dafded39d364e579f68ebf448f17ddf851e9717bfea0e755ab41e0821d450ab4b4e3353823a3b161e9ad0dea

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    slack_bot-events (0.1.0)
+    slack_bot-events (0.4.0)
       class_composer (~> 1.0)
       faraday
       faye-websocket

data/lib/slack_bot/events/client.rb

@@ -3,7 +3,7 @@
 require "eventmachine"
 require "faraday"
 require "faye/websocket"
-require "pry"
+require "slack_bot/events/schematize"
 
 module SlackBot
   module Events
@@ -11,80 +11,62 @@ module SlackBot
       BASE_API = "https://slack.com/api"
 
       def start!
-        EM.run do
-           websocket.on :open do |event|
-            event_tracer(:open)
+        EventMachine.run do
+           websocket.on :open do |socket_event|
+            process(type: :open, socket_event: socket_event) { |**| }
           end
 
-          websocket.on :message do |event|
-            event_tracer(:message) do
-              parsed_data = JSON.parse(event.data)
+          websocket.on :message do |socket_event|
+            process_message(socket_event: socket_event) do |listener:, parsed_data:, schema: nil|
               case parsed_data["type"]
               when "events_api"
-                events_api(parsed_data)
-              when "app_rate_limited"
-                # https://api.slack.com/apis/rate-limits#events
-                # Total allowed workspace events are 30,000 per hour
-                # This message type is received once you have gone beyond that
-                params = {
-                  minute_rate_limited: parsed_data["minute_rate_limited"],
-                  team_id: parsed_data["team_id"],
-                  api_app_id: parsed_data["api_app_id"],
-                }
-                event_tracer("message:app_rate_limited", **params)
-              when "hello"
-                params = {
-                  num_connections: parsed_data["num_connections"],
-                  debug_info_host: parsed_data["debug_info"]["host"],
-                  debug_info_connect_time: parsed_data["debug_info"]["approximate_connection_time"],
-                }
-                event_tracer("message:hello", **params)
+                events_api(handler: listener[:handler], schema: schema, parsed_data: parsed_data)
               end
             end
           end
 
-          websocket.on :close do |event|
-            event_tracer(:close, code: event.code, reason: event.reason)
+          websocket.on :close do |socket_event|
+            process(type: :close, socket_event: socket_event) { |**| }
             @websocket = nil
+
+            # The websocket is closed, explcitly stop the event machine to to end the loop and return to the parent
+            EventMachine.stop
           end
         end
       end
 
-      def events_api(parsed_data)
-        schematized = SlackBot::Events::Schemas::SocketPayload.new(parsed_data)
-        Events.logger.info(schematized.tldr) if Events.config.print_tldr
-        object = Events.config.listeners[schematized.type.to_sym]
-        if object
-          safe_handler(type: schematized.type.to_sym, object: object, schema: schematized, parsed_data: parsed_data)
+      def process_message(socket_event:)
+        schema_data = Schematize.call(data: socket_event.data)
+
+        listener = find_listener(schema: schema_data[:schema]) # Events.config.listeners[schema_data[:schema]&.type.to_sym]
+
+        SlackBot::Events.message_middleware.invoke_message(websocket: websocket, listener: listener, type: :message, socket_event: socket_event, **schema_data) do
+          yield(listener: listener, **schema_data) if block_given?
         end
-        websocket.send("#{{ envelope_id: schematized.envelope_id }.to_json}")
       end
 
-      def event_tracer(type, **params)
-        stringify = params.map { |k,v| "#{k}:#{v}" }.join("; ")
-        Events.logger.info "[Event Received] #{type} #{stringify}"
-        if block_given?
-          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          yield
-          elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-          Events.logger.info "[Event completed] [#{elapsed_time.round(3)}s] #{type} #{stringify}"
+      def process(type:, socket_event:)
+        SlackBot::Events.public_send(:"#{type}_middleware").invoke(type: type, socket_event: socket_event) do
+          yield if block_given?
         end
       end
 
+      def events_api(handler:, schema:, parsed_data:)
+        return if listener.nil?
+
+        Events.logger.info { schema.tldr } if Events.config.print_tldr
+
+        # This gets rescued in the MessageHandler middleware
+        # on_success and on_failure happens there as well
+        handler.call(schema: schema, raw_data: parsed_data)
+      end
+
       private
 
-      def safe_handler(type:, object:, schema:, parsed_data:)
-        Events.logger.info "Received Handler for #{type}"
-        object[:handler].call(schema: schema, raw_data: parsed_data)
-        object[:on_success]&.call(schema)
-      rescue => error
-        Events.logger.error("#{object[:handler]} returned #{error.class} => #{error.message}. Safely returning to websocket. #{error.backtrace[0...10]}")
-
-        begin
-          object[:on_failure]&.call(schema, error)
-        rescue => on_failure_error
-           Events.logger.error("Failure occured during on_failure block. #{on_failure_error}")
-        end
+      def find_listener(schema:)
+        return nil if schema.nil?
+
+        Events.config.listeners[schema.type.to_sym]
       end
 
       def websocket
@@ -103,9 +85,7 @@ module SlackBot
       end
 
       def faraday_headers
-        {
-          'Authorization' => "Bearer #{SlackBot::Events.config.client_socket_token}"
-        }
+        { 'Authorization' => "Bearer #{SlackBot::Events.config.client_socket_token}" }
       end
     end
   end

data/lib/slack_bot/events/configuration.rb

@@ -2,17 +2,35 @@
 
 require "class_composer"
 require "logger"
+require "slack_bot/events/middleware/chain"
 
 module SlackBot
   module Events
     class Configuration
       include ClassComposer::Generator
+
+      ALLOWED_ACKNOWLEDGE = [
+        DEFAULT_ACKNOWLEDGE = :on_complete,
+        :on_success,
+        :on_receive,
+      ]
+
       add_composer :client_id, allowed: String, default: ENV["SLACK_CLIENT_ID"]
       add_composer :client_secret, allowed: String, default: ENV["SLACK_CLIENT_SECRET"]
       add_composer :client_signing_secret, allowed: String, default: ENV["SLACK_SIGNING_SECRET"]
       add_composer :client_socket_token, allowed: String, default: ENV["SLACK_SOCKET_TOKEN"]
       add_composer :client_verification_token, allowed: String, default: ENV["SLACK_VERIFICATION_TOKEN"]
       add_composer :print_tldr, allowed: [true.class, false.class], default: true
+      add_composer :message_middleware, allowed: Middleware::Chain, default: Middleware::Chain.new(type: :message)
+      add_composer :open_middleware, allowed: Middleware::Chain, default: Middleware::Chain.new(type: :open)
+      add_composer :close_middleware, allowed: Middleware::Chain, default: Middleware::Chain.new(type: :close)
+      add_composer :envelope_acknowledge, allowed: Symbol, default: DEFAULT_ACKNOWLEDGE, validator: ->(val) { ALLOWED_ACKNOWLEDGE.include?(val) }, invalid_message: ->(_) { "Must by a Symbol in #{ALLOWED_ACKNOWLEDGE}" }
+
+      ALLOWED_ACKNOWLEDGE.each do |ack|
+        define_method :"acknowledge_#{ack}?" do
+          envelope_acknowledge == ack
+        end
+      end
 
       def register_listener(name:, handler:, on_success: nil, on_failure: nil)
         if event_handler = listeners[name.to_sym]

data/lib/slack_bot/events/middleware/chain.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "slack_bot/events/middleware/event_tracer"
+require "slack_bot/events/middleware/message_handler"
+
+####################
+#
+# Adapted from Sidekiq:
+# https://github.com/sidekiq/sidekiq/blob/main/lib/sidekiq/middleware/chain.rb
+#
+####################
+
+module SlackBot
+  module Events
+    module Middleware
+      class Chain
+        include Enumerable
+
+        attr_reader :type
+
+        DEFAULT_ENTRIES = {
+          message: [Middleware::EventTracer, Middleware::MessageHandler],
+          open: [Middleware::EventTracer],
+          close: [Middleware::EventTracer],
+        }
+
+        def initialize(type:)
+          @type = type
+        end
+
+        def self.default_entry(type)
+          DEFAULT_ENTRIES[type].map { Entry.new(_1) }
+        end
+
+        def entries
+          @entries ||= self.class.default_entry(type)
+        end
+
+        def remove(klass)
+          raise ArgumentError, "Unable to remove default Middleware #{klass}" if self.class.default_entry.map(:klass).include?(klass)
+
+          entries.delete_if { |entry| entry.klass == klass }
+        end
+
+        def add(klass, *args)
+          remove(klass)
+          entries << Entry.new(klass, args)
+        end
+
+        def prepend(klass, *args)
+          remove(klass)
+          entries.insert(0, Entry.new(klass, args))
+        end
+
+        def insert_before(oldklass, newklass, *args)
+          i = entries.index { |entry| entry.klass == newklass }
+          new_entry = i.nil? ? Entry.new(klass, args) : entries.delete_at(i)
+          i = entries.index { |entry| entry.klass == oldklass } || 0
+          entries.insert(i, new_entry)
+        end
+
+        def insert_after(oldklass, newklass, *args)
+          i = entries.index { |entry| entry.klass == newklass }
+          new_entry = i.nil? ? Entry.new(klass, args) : entries.delete_at(i)
+          i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+          entries.insert(i + 1, new_entry)
+        end
+
+        def exists?(klass)
+          any? { |entry| entry.klass == klass }
+        end
+
+        def empty?
+          entries.nil? || entries.empty?
+        end
+
+        def retrieve
+          map(&:instance!)
+        end
+
+        def each(&block)
+          entries.each(&block)
+        end
+
+        def clear
+          @entries = nil
+        end
+
+        def invoke_message(type:, socket_event:, parsed_data:, websocket:, listener:, schema: nil)
+          return yield if empty?
+
+          chain = retrieve
+          traverse_chain = proc do
+            if chain.empty?
+              yield
+            else
+              params = {
+                parsed_data: parsed_data,
+                schema: schema,
+                socket_event: socket_event,
+                listener: listener,
+                type: type,
+                websocket: websocket,
+              }
+              chain.shift.call(**params, &traverse_chain)
+            end
+          end
+          traverse_chain.call
+        end
+
+        def invoke(type:, socket_event:)
+          return yield if empty?
+
+          chain = retrieve
+          traverse_chain = proc do
+            if chain.empty?
+              yield
+            else
+              chain.shift.call(type: type, socket_event: socket_event, &traverse_chain)
+            end
+          end
+          traverse_chain.call
+        end
+
+        def inspect_me
+          entries.map do |e|
+            [
+              e.klass,
+              e.args
+            ]
+          end
+        end
+      end
+
+      class Entry
+        attr_reader :klass
+        attr_reader :args
+
+        def initialize(klass, args = [])
+          @klass = klass
+          @args = args
+        end
+
+        def instance!
+          klass.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/middleware/event_tracer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SlackBot
+  module Events
+    module Middleware
+      class EventTracer
+        def call(type:, socket_event:, schema: nil, parsed_data: nil, **params)
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          temp_type = type.dup.to_s
+          case type
+          when :close
+            additional_info = "code: #{socket_event.code} reason:#{socket_event.reason}"
+          when :message
+            accurate_type = parsed_data.dig("payload","event","subtype") || parsed_data.dig("payload","event","type")
+            p_type = [
+              parsed_data.dig("type"),
+              accurate_type
+            ].compact.join(":")
+            case p_type
+            when "app_rate_limited"
+              # https://api.slack.com/apis/rate-limits#events
+              # Total allowed workspace events are 30,000 per hour
+              # This message type is received once you have gone beyond that
+              temp_type += ":#{p_type}"
+              additional_info = "minute_rate_limited:#{parsed_data["minute_rate_limited"]} " \
+                "team_id:#{parsed_data["team_id"]} " \
+                "api_app_id:#{parsed_data["api_app_id"]}"
+            else
+              # Expected other types are `events_api` and `hello`
+              temp_type += ":#{p_type}"
+            end
+          end
+
+          Events.logger.info { "[Event Received] #{temp_type} #{additional_info}" }
+
+          yield
+
+          elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+          Events.logger.info { "[Event Finished] #{temp_type} [#{(elapsed_time * 1000).round(2)}ms]" }
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/middleware/message_handler.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SlackBot
+  module Events
+    module Middleware
+      class MessageHandler
+        def call(schema:, websocket:, listener:, **params)
+          if SlackBot::Events.config.acknowledge_on_receive?
+            acknowledge!(websocket: websocket, schema: schema)
+          end
+
+          yield
+
+          listener[:on_success]&.call(schema) if listener
+
+          if SlackBot::Events.config.acknowledge_on_success? || SlackBot::Events.config.acknowledge_on_complete?
+            acknowledge!(websocket: websocket, schema: schema)
+          end
+        rescue StandardError => error
+          puts error.message
+          puts error.backtrace
+          Events.logger.error do
+            "#{listener[:handler]} returned #{error.class} => #{error.message}. #{error.backtrace[0...10]}"
+          end
+
+          begin
+            listener[:on_failure]&.call(schema, error) if listener
+          rescue StandardError => on_failure_error
+             Events.logger.error("Failure occured during on_failure block. #{on_failure_error}")
+          end
+
+          if SlackBot::Events.config.acknowledge_on_complete?
+            acknowledge!(websocket: websocket, schema: schema)
+          elsif SlackBot::Events.config.acknowledge_on_success?
+            Events.logger.debug do
+              "Envelope acknowledgment skipped. Ackowledgment on success only. Slack may send a duplicate message"
+            end
+          end
+        end
+
+        private
+
+        def acknowledge!(websocket:, schema:)
+          return if schema.nil?
+
+          websocket.send("#{{ envelope_id: schema.envelope_id }.to_json}")
+          Events.logger.debug { "Envelope acknowledgment completed [#{SlackBot::Events.config.envelope_acknowledge}]" }
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/schemas/socket_payload.rb

@@ -28,7 +28,7 @@ module SlackBot
         def tldr
           retry_language = "#{retry_attempt}"
           retry_language += ":#{retry_reason}" if retry_attempt > 0
-          "tldr:#{payload.event.tldr}; retry:#{retry_language}"
+          "#{payload.event.tldr}; retry:#{retry_language}"
         end
       end
     end

data/lib/slack_bot/events/schemas/type/message.rb

@@ -39,7 +39,7 @@ module SlackBot
           end
 
           def tldr
-            "type: #{type}; channel:#{channel}; raw_text:#{text}"
+            "type:#{type}; user:#{user}; channel:#{channel}; ts_id:#{combined_id}"
           end
 
           def thread_ts
@@ -52,6 +52,10 @@ module SlackBot
 
           private
 
+          def combined_id
+            thread_ts ? "#{ts}:#{thread_ts}" : ts
+          end
+
           def return_nil?(val)
             JsonSchematize::EmptyValue === val || val.nil?
           end

data/lib/slack_bot/events/schemas/type/reaction_modified.rb

@@ -28,7 +28,7 @@ module SlackBot
           end
 
           def tldr
-            "type: #{type}; channel:#{channel}; reaction:#{reaction}"
+            "type:#{type}; user:#{item_user}; channel:#{channel}; reaction:#{reaction}"
           end
         end
       end

data/lib/slack_bot/events/schematize.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SlackBot
+  module Events
+    module Schematize
+      def self.message(parsed_data)
+        case parsed_data["type"]
+        when "events_api"
+          return SlackBot::Events::Schemas::SocketPayload
+        when "app_rate_limited"
+        when "hello"
+        end
+      end
+
+      def self.call(data:)
+        parsed_data = JSON.parse(data)
+        return { parsed_data: parsed_data } unless schema_klass = message(parsed_data)
+
+        if schema_klass.respond_to?(:call)
+          { schema: schema_klass.call(parsed_data).new(parsed_data), parsed_data: parsed_data }
+        else
+          { schema: schema_klass.new(parsed_data), parsed_data: parsed_data }
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/version.rb

@@ -2,6 +2,6 @@
 
 module SlackBot
   module Events
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/slack_bot/events.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require "pry"
+
 require "slack_bot/events/configuration"
 require "slack_bot/events/client"
+require "slack_bot/events/middleware/chain"
 require "slack_bot/events/schemas/socket_payload"
 
 module SlackBot
@@ -40,5 +43,17 @@ module SlackBot
     def self.logger
       config.logger
     end
+
+    def self.message_middleware
+      config.message_middleware
+    end
+
+    def self.open_middleware
+      config.open_middleware
+    end
+
+    def self.close_middleware
+      config.close_middleware
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_bot-events
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -134,6 +134,9 @@ files:
 - lib/slack_bot/events.rb
 - lib/slack_bot/events/client.rb
 - lib/slack_bot/events/configuration.rb
+- lib/slack_bot/events/middleware/chain.rb
+- lib/slack_bot/events/middleware/event_tracer.rb
+- lib/slack_bot/events/middleware/message_handler.rb
 - lib/slack_bot/events/schemas/authorization.rb
 - lib/slack_bot/events/schemas/data_payload.rb
 - lib/slack_bot/events/schemas/socket_payload.rb
@@ -144,6 +147,7 @@ files:
 - lib/slack_bot/events/schemas/type/item.rb
 - lib/slack_bot/events/schemas/type/message.rb
 - lib/slack_bot/events/schemas/type/reaction_modified.rb
+- lib/slack_bot/events/schematize.rb
 - lib/slack_bot/events/version.rb
 - slack_bot-events.gemspec
 homepage: https://github.com/matt-taylor/slack_bot-events