slack_bot-events 0.0.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 214337c85ccf72326faf95c1fca9b46bc46293d98e404bb3dc8856bec70534c3
-  data.tar.gz: 4fa855274d80b70ece04fad550fe949fbda80557b8629d2595f40f9d09c66b7b
+  metadata.gz: e221d5ba2b7822f18b4079b73bc35005488510570b1c6bf1121b29ae3a38a85f
+  data.tar.gz: 7c6fd667337ad3eaefc080abac2d53295b6226c41570dcebc118eb321e218a0b
 SHA512:
-  metadata.gz: be57b63b5ce9a1aeea150b8944a38a764094be0970c9cddff0538877f70ba3723fa9dd869b4b5df916ea2474ab7fd05c56c89c2dc984a760d87039f8dc7dfe95
-  data.tar.gz: 58ac99258d980088a670194c496248edaad9e4cb2dcd1639278079a9108e983a8981c56419781d9db3ce468f0558f81e6a499b41cd8b0edecfa834bf618d039e
+  metadata.gz: 9545811f097ea137483b27bfd4b93cfb9d64040487051fd9f906de4d67e09503768fa4341faad9eed36348edf644ad33be7f9109f3c5a9d5741d59fc9c8ca17b
+  data.tar.gz: 2afc096dd076de82f0f3443a7ac437be405f6b8613db994072a94cb05623797cc631b178e163c756ddfbd7f2c29e337bbb42db5fe71e42aed0b5b148c3bfd5ea

data/Gemfile.lock

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

data/lib/slack_bot/events/client.rb

@@ -13,32 +13,80 @@ module SlackBot
       def start!
         EM.run do
            websocket.on :open do |event|
-            p [:open]
+            event_tracer(:open)
           end
 
           websocket.on :message do |event|
-            parsed_data = JSON.parse(event.data)
-            if parsed_data["type"] == "events_api"
-              puts parsed_data.to_json
-              item = SlackBot::Events::Schemas::SocketPayload.new(parsed_data)
-              s = {
-                type: item.payload.event.type,
-                tldr: item.payload.event.tldr,
-              }
-              puts s
-              websocket.send("#{{ envelope_id: item.envelope_id }.to_json}")
-            else
-              puts event.data
+            event_tracer(:message) do
+              parsed_data = JSON.parse(event.data)
+              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)
+              end
             end
           end
 
           websocket.on :close do |event|
-            p [:close, event.code, event.reason]
+            event_tracer(:close, code: event.code, reason: event.reason)
             @websocket = nil
           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)
+        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}"
+        end
+      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
+      end
+
       def websocket
         @websocket ||= Faye::WebSocket::Client.new(socket_endpoint)
       end

data/lib/slack_bot/events/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "class_composer"
+require "logger"
 
 module SlackBot
   module Events
@@ -11,22 +12,59 @@ module SlackBot
       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
 
-      def register_listener(name:, handler:)
-        @listeners ||= {}
-
-        if @listeners.has_key(name.to_sym)
+      def register_listener(name:, handler:, on_success: nil, on_failure: nil)
+        if event_handler = listeners[name.to_sym]
+          logger.warn "`#{name}` already exists as listener event. Reseting with new input"
         end
 
-        @listeners[name] = handler
+        validate_listener!(handler: handler, on_success: on_success, on_failure: on_failure)
 
+        listeners[name.to_sym] = { handler: handler, name: name, on_success: on_success, on_failure: on_failure }
         true
       end
 
       def remove_listener(name:)
+        listeners ||= {}
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def logger=(log)
+        @logger = log
+      end
+
+      def listeners
         @listeners ||= {}
+      end
+
+      private
+
+      def validate_listener!(handler:, on_success:, on_failure:)
+        unless retreive_method(object: handler, meth_name: :call)
+          raise ArgumentError, "When present, handler argument needs to respond_to :call with schema: and raw_data: kwargs"
+        end
 
+        if on_success
+          unless retreive_method(object: on_success, meth_name: :call)
+            raise ArgumentError, "When present, on_success argument needs to respond_to :call with 1 arguments passed in"
+          end
+        end
+
+        if on_failure
+          unless retreive_method(object: on_failure, meth_name: :call)
+            raise ArgumentError, "When present, on_failure argument needs to respond_to :call with 2 arguments passed in"
+          end
+        end
+      end
 
+      def retreive_method(object:, meth_name:)
+        object.method(meth_name.to_sym)
+      rescue NameError
+        nil
       end
     end
   end

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

@@ -19,6 +19,17 @@ module SlackBot
         add_field name: :accepts_response_payload, type: JsonSchematize::Boolean
         add_field name: :retry_attempt, type: Integer
         add_field name: :retry_reason, type: String
+
+
+        def type
+          payload.event.type
+        end
+
+        def tldr
+          retry_language = "#{retry_attempt}"
+          retry_language += ":#{retry_reason}" if retry_attempt > 0
+          "tldr:#{payload.event.tldr}; retry:#{retry_language}"
+        end
       end
     end
   end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json_schematize"
+require "json_schematize/generator"
+
+module SlackBot
+  module Events
+    module Schemas
+      module Type
+        class BotProfile < JsonSchematize::Generator
+          schema_default option: :dig_type, value: :string
+
+          add_field name: :id, type: String
+          add_field name: :app_id, type: String
+          add_field name: :name, type: String
+          add_field name: :deleted, type: JsonSchematize::Boolean
+          add_field name: :updated, type: String
+          add_field name: :team_id, type: String
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,7 @@ require "json_schematize"
 require "json_schematize/generator"
 
 require "slack_bot/events/schemas/type/block"
+require "slack_bot/events/schemas/type/bot_profile"
 
 module SlackBot
   module Events
@@ -20,14 +21,40 @@ module SlackBot
           add_field name: :team, type: String
 
           add_field name: :blocks, type: SlackBot::Events::Schemas::Type::Block, array_of_types: true
+          add_field name: :bot_profile, type: SlackBot::Events::Schemas::Type::BotProfile, required: false
+
+          add_field name: :thread_ts, type: String, required: false
+          add_field name: :parent_user_id, type: String, required: false
 
           add_field name: :channel, type: String
           add_field name: :event_ts, type: String
           add_field name: :channel_type, type: String
 
+          def made_from_user?
+            bot_profile.nil? || JsonSchematize::EmptyValue === bot_profile
+          end
+
+          def made_from_bot?
+            !made_from_user?
+          end
+
           def tldr
             "type: #{type}; channel:#{channel}; raw_text:#{text}"
           end
+
+          def thread_ts
+            return_nil?(@thread_ts) ? nil : @thread_ts
+          end
+
+          def parent_user_id
+            return_nil?(@parent_user_id) ? nil : @parent_user_id
+          end
+
+          private
+
+          def return_nil?(val)
+            JsonSchematize::EmptyValue === val || val.nil?
+          end
         end
       end
     end

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

@@ -23,6 +23,10 @@ module SlackBot
             item.channel
           end
 
+          def message_ts
+            item.ts
+          end
+
           def tldr
             "type: #{type}; channel:#{channel}; reaction:#{reaction}"
           end

data/lib/slack_bot/events/version.rb

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

data/lib/slack_bot/events.rb

@@ -29,12 +29,16 @@ module SlackBot
       raise Error, "Expected configuration to be a SlackBot::Events::Configuration"
     end
 
-    def self.register_listener(name:, handler:)
-      config.register_listener(name: name, handler: handler)
+    def self.register_listener(name:, handler:, on_success: nil, on_failure: nil)
+      config.register_listener(name: name, handler: handler, on_success: on_success, on_failure: on_failure)
     end
 
     def self.remove_listener(name:)
       config.remove_listener(name: name)
     end
+
+    def self.logger
+      config.logger
+    end
   end
 end

data/lib/slack_bot-events.rb

@@ -0,0 +1 @@
+require "slack_bot/events"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_bot-events
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-16 00:00:00.000000000 Z
+date: 2024-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -130,6 +130,7 @@ files:
 - bin/setup
 - bin/start
 - docker-compose.yml
+- lib/slack_bot-events.rb
 - lib/slack_bot/events.rb
 - lib/slack_bot/events/client.rb
 - lib/slack_bot/events/configuration.rb
@@ -138,6 +139,7 @@ files:
 - lib/slack_bot/events/schemas/socket_payload.rb
 - lib/slack_bot/events/schemas/type/base.rb
 - lib/slack_bot/events/schemas/type/block.rb
+- lib/slack_bot/events/schemas/type/bot_profile.rb
 - lib/slack_bot/events/schemas/type/element.rb
 - lib/slack_bot/events/schemas/type/item.rb
 - lib/slack_bot/events/schemas/type/message.rb