eureka-bot 1.0.16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ea62c75b6709c9fbbc8afdbe0c6083e10674edb
+  data.tar.gz: c5fe994ed3a20a1159ca1e4b6f1884158586ec75
+SHA512:
+  metadata.gz: a1a16fe9ea47346ac3f887f4c62067bd375776cc896468987f05a68d35e82c7f98aeb73bdecf810a3482cdfd8b21fd16c3e4e75166a54a716e288158c0844933
+  data.tar.gz: 9b2bb0afc377b35c07b7747ac8bed6a049388030c1e123694dc46619c8a6ba6fa42e30a1f3aea14ae4c2ba0231f29b0ebbec2320320f1912cede9be89cd88381

data/.gitignore

@@ -0,0 +1,30 @@
+/.bundle
+
+/.yardoc
+/_yardoc/
+/coverage/
+/pkg/
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+mkmf.log
+
+nbproject
+.idea
+*~
+
+*.swp
+*.swap
+*.bundle
+*.so
+*.o
+*.a
+
+.vagrant
+.ruby-env
+.DS_Store
+Vagrantfile
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 dizer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+# Eureka Bot framework
+

data/eureka-bot.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eureka_bot/version'
+
+Gem::Specification.new do |spec|
+  spec.name     = 'eureka-bot'
+  spec.version  = EurekaBot::VERSION
+  spec.authors  = ['Yury Alexandrov']
+  spec.email    = ['dizeru@gmail.com']
+  spec.summary  = %q{Run your messenger bots}
+  spec.homepage = 'https://github.com/dizer/eureka-bot'
+  spec.license  = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+  spec.bindir = 'bin'
+
+  spec.add_runtime_dependency 'activesupport', '~> 5.0', '>= 5.0.0'
+  spec.add_runtime_dependency 'activejob', '~> 5.0', '>= 5.0.0'
+
+  spec.add_development_dependency 'rspec', '~> 3.5', '>= 3.5.0'
+  spec.add_development_dependency 'webmock', '~> 3.3.0', '>= 3.3.0'
+end

data/lib/eureka-bot.rb

@@ -0,0 +1,37 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/concern'
+require 'active_support/notifications'
+
+module EurekaBot
+  extend ActiveSupport::Autoload
+  cattr_reader :logger
+
+  autoload :Controller
+  autoload :Exceptions
+  autoload :Instrumentation
+  autoload :Job
+  autoload :Resolver
+  autoload :Sender
+  autoload :Version
+
+  eager_autoload do
+    autoload :Integration
+    autoload :Notifications
+  end
+
+  include EurekaBot::Exceptions
+
+  def self.logger=(logger)
+    @@logger = logger
+    EurekaBot::Job.logger = logger
+    logger
+  end
+end
+
+EurekaBot.logger       = Logger.new(nil)
+EurekaBot.logger.level = Logger::INFO
+
+EurekaBot.eager_load!

data/lib/eureka_bot/controller.rb

@@ -0,0 +1,69 @@
+class EurekaBot::Controller
+  extend ActiveSupport::Autoload
+  include ActiveSupport::Callbacks
+  include EurekaBot::Instrumentation
+
+  define_callbacks :action
+
+  autoload :Response
+
+  attr_reader :params, :message, :logger, :response
+  # cattr_accessor :exception_handler
+
+  def initialize(params: {}, message: nil, response: nil, logger: EurekaBot.logger)
+    @params   = params
+    @message  = message
+    @logger   = logger
+    @response = response || response_class.new(logger: logger)
+    @response.controller = self
+  end
+
+  def execute(action)
+    if respond_to?(action, include_all: false)
+      instrument 'controller.execute' do
+        run_callbacks :action do
+          public_send(action)
+        end
+      end
+    else
+      raise UnknownAction.new("Action #{action} is not defined in #{self.class}")
+    end
+    self
+  end
+
+  def answer(**params)
+    instrument 'controller.answer', params do
+      response << params
+      nil
+    end
+  end
+
+  def redirect(controller, action)
+    instance = controller.new(
+        params:   params,
+        message:  message,
+        response: response,
+        logger:   logger
+    )
+    instrument 'controller.redirect', {from: self.class.to_s, to: {controller: controller.to_s, action: action}} do
+      instance.public_send(action)
+    end
+  end
+
+  def response_class
+    EurekaBot::Controller::Response
+  end
+
+  def trace_error(e, params={})
+    logger.error(e.http_body) if e.respond_to?(:http_body)
+    EurekaBot.exception_handler(e, self.class, params)
+  end
+
+  def self.has_action?(action)
+    return false unless action.present?
+    public_instance_methods(false).include?(action.to_sym)
+  end
+
+  class UnknownAction < StandardError; end
+
+end

data/lib/eureka_bot/controller/response.rb

@@ -0,0 +1,42 @@
+class EurekaBot::Controller::Response
+  include ActiveSupport::Callbacks
+  define_callbacks :add
+
+  attr_reader :logger, :data
+  attr_accessor :controller
+
+  def initialize(logger: EurekaBot.logger)
+    @logger = logger
+    @data   = []
+    @order_counters = {}
+  end
+
+  def add(sync: false, **params)
+    run_callbacks :add do
+      message = params
+      if message[:order_queue]
+        @order_counters[message[:order_queue]] = (@order_counters[message[:order_queue]] || 0) + 1
+        message = {order: @order_counters[message[:order_queue]]}.merge(message)
+      end
+      if sync
+        self.class.sender_class.new.deliver(message)
+      else
+        @data << message
+        nil
+      end
+    end
+  end
+
+  def <<(params={})
+    add(params)
+  end
+
+  def to_a
+    data
+  end
+
+  def self.sender_class
+    @@sender_class ||= EurekaBot::Sender
+  end
+
+end

data/lib/eureka_bot/exceptions.rb

@@ -0,0 +1,28 @@
+module EurekaBot::Exceptions
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :exception_chain
+
+    def self.add_exception_handler(&block)
+      self.exception_chain = (self.exception_chain || []) + [block]
+    end
+
+    def self.exception_handler(e, klass, args)
+      self.exception_chain.each do |handler|
+        handler.call(e, klass, args) rescue nil
+      end
+    end
+
+    add_exception_handler do |e, klass, args|
+      EurekaBot.logger.error(
+          {
+              class:     e.class.to_s,
+              message:   e.message,
+              args:      args,
+              backtrace: e.backtrace
+          }.to_json
+      )
+    end
+  end
+end

data/lib/eureka_bot/instrumentation.rb

@@ -0,0 +1,25 @@
+module EurekaBot::Instrumentation
+  extend ActiveSupport::Concern
+
+  def instrument(name, level: Logger::DEBUG, **payload, &block)
+    self.class.instrument(name, level: level, **payload, &block)
+  end
+
+  def self.prefix
+    'eureka-bot'
+  end
+
+  class_methods do
+    def instrument(name, level: Logger::DEBUG, **payload, &block)
+      ActiveSupport::Notifications.instrument(
+          [
+              EurekaBot::Instrumentation.prefix,
+              name
+          ].compact.join('.'),
+          {level: level}.merge(payload),
+          &block
+      )
+    end
+  end
+
+end

data/lib/eureka_bot/integration.rb

@@ -0,0 +1,11 @@
+module EurekaBot::Integration
+  extend ActiveSupport::Autoload
+
+  autoload :NewRelic
+
+  if defined?(::NewRelic)
+    EurekaBot.logger.debug 'loading NewRelic integration'
+    EurekaBot.include(EurekaBot::Integration::NewRelic)
+  end
+
+end

data/lib/eureka_bot/integration/new_relic.rb

@@ -0,0 +1,10 @@
+module EurekaBot::Integration::NewRelic
+  extend ActiveSupport::Concern
+
+  included do
+    add_exception_handler do |e, klass, args|
+      ::NewRelic::Agent.notice_error(e, custom_params: args)
+    end
+  end
+end
+

data/lib/eureka_bot/job.rb

@@ -0,0 +1,14 @@
+require 'active_job'
+
+class EurekaBot::Job < ActiveJob::Base
+  extend ActiveSupport::Autoload
+  autoload :Input
+  autoload :Output
+  include EurekaBot::Instrumentation
+
+  queue_as do
+    self.class.name.underscore.gsub('/', '__')
+  end
+
+  self.logger = EurekaBot.logger
+end

data/lib/eureka_bot/job/input.rb

@@ -0,0 +1,18 @@
+class EurekaBot::Job::Input < EurekaBot::Job
+  queue_as :input
+
+  def perform(resolver_class, message)
+    instrument 'job.input' do
+      resolver = resolver_class.constantize.new(
+          message: message,
+          logger:  logger
+      )
+      resolver.execute
+    end
+  rescue StandardError => e
+    EurekaBot.exception_handler(e, self.class, resolver_class: resolver_class, message: message)
+  end
+
+  class UnknownResolverClass < StandardError;
+  end
+end

data/lib/eureka_bot/job/output.rb

@@ -0,0 +1,12 @@
+class EurekaBot::Job::Output < EurekaBot::Job
+  queue_as :output
+
+  def perform(sender_class, message, *args)
+    instrument 'job.output' do
+      sender_class.constantize.new.deliver(message, *args)
+    end
+  rescue StandardError => e
+    EurekaBot.exception_handler(e, self.class, sender_class: sender_class, message: message)
+  end
+
+end

data/lib/eureka_bot/notifications.rb

@@ -0,0 +1,25 @@
+module EurekaBot::Notification
+  def self.log_notification(severity=::Logger::DEBUG, name, started, finished, id, payload)
+    EurekaBot.logger.add(
+        severity,
+        {
+            name:           name,
+            execution_time: finished - started,
+            started:        started,
+            finished:       finished,
+            id:             id,
+            payload:        payload
+        }.to_json
+    )
+  end
+end
+
+ActiveSupport::Notifications.subscribe /eureka-bot\..*/ do |*args|
+  severity = if args[0] == 'eureka-bot.job.perform'
+               ::Logger::INFO
+             else
+               ::Logger::DEBUG
+             end
+  EurekaBot::Notification.log_notification(severity, *args)
+end
+

data/lib/eureka_bot/resolver.rb

@@ -0,0 +1,78 @@
+class EurekaBot::Resolver
+  include EurekaBot::Instrumentation
+
+  class ActionNotFound < StandardError; end
+  class ControllerNotFound < StandardError; end
+
+  attr_reader :logger, :message, :response, :controller
+
+  def initialize(message:, response: nil, logger: EurekaBot.logger)
+    @logger   = logger
+    @message  = message
+    @response = response
+  end
+
+  def resolve
+    nil
+  end
+
+  def resolved
+    @resolved ||= begin
+      resolved = resolve
+      instrument 'resolver.resolved', level: Logger::INFO, result: resolved, message: message
+      resolved
+    end
+  end
+
+  def execute
+    raise ControllerNotFound.new("Can't resolve #{message}") unless resolved
+    @controller = resolve_controller(resolved[:controller]).new(
+        params:   resolved[:params] || {},
+        message:  message,
+        logger:   logger,
+        response: response
+    )
+    instrument 'resolver.execute' do
+      controller.execute(resolved[:action])
+    end
+    self
+  end
+
+  def parameterize(str)
+    ActiveSupport::Inflector.parameterize(str, separator: '_').presence
+  end
+
+  def decode_params(str, delimiter: ':')
+    action_raw, version, *params = str.split(delimiter)
+    {
+        action:  parameterize(action_raw),
+        version: version,
+        params:  {raw: params, version: version} || {}
+    }
+  end
+
+  def encode_params(action:, version: 'v1', params: [])
+    ([action, version] + params.map(&:to_json)).join(':')
+  end
+
+  def resolve_controller(klass)
+    instrument 'resolver.resolve_controller' do
+      return klass if klass.is_a?(Class) && klass <= EurekaBot::Controller
+      camelized = ActiveSupport::Inflector.camelize(klass)
+      camelized = [camelized, 'Controller'].join unless camelized.include?('Controller')
+      [
+          camelized,
+          [controller_namespace, camelized].join('::')
+      ].each do |variant|
+        constant= ActiveSupport::Inflector.safe_constantize(variant)
+        return constant if constant
+      end
+      raise ControllerNotFound.new(klass)
+    end
+  end
+
+  def controller_namespace
+    EurekaBot
+  end
+
+end

data/lib/eureka_bot/sender.rb

@@ -0,0 +1,8 @@
+class EurekaBot::Sender
+  include EurekaBot::Instrumentation
+
+  def deliver(message)
+    true
+  end
+
+end

data/lib/eureka_bot/version.rb

@@ -0,0 +1,3 @@
+module EurekaBot
+  VERSION = '1.0.16'
+end

data/spec/eureka-bot/controller/response_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe EurekaBot::Controller::Response do
+
+  context 'message order' do
+    let(:response) { EurekaBot::Controller::Response.new }
+    it do
+      response.add(order_queue: 'test-lock')
+      response.add(order_queue: 'test-lock')
+      response.add(order_queue: 'test-lock-2')
+      response.add
+      expect(response.to_a).to include(
+                                   hash_including(order_queue: 'test-lock', order: 1),
+                                   hash_including(order_queue: 'test-lock', order: 2),
+                                   hash_including(order_queue: 'test-lock-2', order: 1),
+                                   hash_not_including(:order_queue, :order)
+                               )
+    end
+  end
+
+end

data/spec/eureka-bot/controller_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe EurekaBot::Controller do
+
+  context 'execute' do
+    let(:controller_klass) {
+      Class.new(EurekaBot::Controller) do
+        def sample_action; end
+      end
+    }
+    let(:controller) { controller_klass.new }
+    it do
+      expect(controller).to receive(:sample_action).once
+      controller.execute(:sample_action)
+    end
+  end
+
+  context 'response' do
+    let(:controller) { EurekaBot::Controller.new }
+
+    it 'is EurekaBot::Controller::Response subclass' do
+      expect(controller.response).to be_a_kind_of(EurekaBot::Controller::Response)
+    end
+
+    context '#answer' do
+      let(:controller) do
+        Class.new(EurekaBot::Controller) do
+          def some_action
+            answer(some_action: 'finished')
+          end
+        end.new
+      end
+
+      before do
+        controller.some_action
+      end
+
+      it do
+        expect(controller.response.to_a).to include(include(some_action: 'finished'))
+      end
+    end
+  end
+
+  context 'redirect' do
+    let(:controller_klass) {
+      Class.new(EurekaBot::Controller) do
+        def sample_action_1
+          redirect params[:klass], :sample_action_2
+        end
+        def sample_action_2; end
+      end
+    }
+    let(:controller) { controller_klass.new(params: {klass: controller_klass}) }
+    it do
+      expect_any_instance_of(controller_klass).to receive(:sample_action_2).once
+      controller.execute(:sample_action_1)
+    end
+  end
+end

data/spec/eureka-bot/instrumentation_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe EurekaBot::Instrumentation do
+  context 'level' do
+    let(:resolver) { EurekaBot::Resolver.new(message: {}) }
+    it do
+      payloads = []
+      subscriber = ActiveSupport::Notifications.subscribe /.*/ do |name, started, finished, id, payload|
+        expect(payload).to include(:level)
+        payloads << payload
+      end
+
+      expect{resolver.resolved}.to change{payloads.length}.from(0).to(1)
+
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+  end
+end

data/spec/eureka-bot/job_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+RSpec.describe EurekaBot::Job do
+  context '#execute' do
+    let(:resolver_class) do
+      class TestResolver < EurekaBot::Resolver
+      end
+      TestResolver
+    end
+
+    let(:controller_class) do
+      class TestController < EurekaBot::Controller
+        def some_action
+          answer(some_action: 'finished')
+        end
+      end
+      TestController
+    end
+
+    let(:job_class) do
+      $job_result = nil
+      class TestJob < EurekaBot::Job::Input
+        def perform(resolver_class, message)
+          $job_result = super
+        end
+      end
+      TestJob
+    end
+
+    after do
+      Object.send(:remove_const, :TestController)
+      Object.send(:remove_const, :TestJob)
+      Object.send(:remove_const, :TestResolver)
+    end
+
+    before do
+      allow_any_instance_of(resolver_class).to receive(:resolve).and_return(
+          controller: controller_class,
+          action:     :some_action
+      )
+    end
+
+    context 'results' do
+      before do
+        job_class.perform_later(resolver_class.to_s, {})
+      end
+
+      it do
+        expect($job_result).to be
+        expect(
+            $job_result.controller.response.to_a
+        ).to include(include(some_action: 'finished'))
+      end
+    end
+
+    context 'exceptions' do
+      let(:controller_class) do
+        class TestController < EurekaBot::Controller
+          def some_action
+            raise StandardError.new('test action error')
+          end
+        end
+        TestController
+      end
+      it do
+        $result = nil
+        EurekaBot.add_exception_handler do |e|
+          $result = e.message
+        end
+        expect{
+          job_class.perform_later(resolver_class.to_s, {})
+        }.to change{$result}.from(nil).to('test action error')
+      end
+    end
+  end
+end

data/spec/eureka-bot/resolver_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe EurekaBot::Resolver do
+  context '#execute' do
+    let(:controller_class) do
+      Class.new(EurekaBot::Controller) do
+        def some_action
+          answer(some_action: 'finished')
+        end
+      end
+    end
+
+    let(:resolver) do
+      Class.new(EurekaBot::Resolver).new(message: {})
+    end
+
+    before do
+      allow(resolver).to receive(:resolve).and_return(
+          controller: controller_class,
+          action:     :some_action
+      )
+      resolver.execute
+    end
+
+    it do
+      expect(resolver.controller.response.to_a).to include(include(some_action: 'finished'))
+    end
+  end
+
+  context '#exception' do
+    let(:controller_class) do
+      Class.new(EurekaBot::Controller) do
+        def some_action
+          raise StandardError.new
+        end
+      end
+    end
+
+    let(:resolver) do
+      Class.new(EurekaBot::Resolver).new(message: {})
+    end
+
+    before do
+      allow(resolver).to receive(:resolve).and_return(
+          controller: controller_class,
+          action:     :some_action
+      )
+    end
+
+    it do
+      expect{resolver.execute}.to raise_error(StandardError)
+    end
+  end
+
+  context 'namespace' do
+    let(:controller_class) do
+      Class.new(EurekaBot::Controller) do
+        def some_action
+          answer(some_action: 'finished')
+        end
+      end
+    end
+
+    let(:resolver_class) do
+      Class.new(EurekaBot::Resolver) do
+        def resolve
+            return {
+                controller: 'test',
+                action:     :some_action
+            }
+        end
+
+        def controller_namespace
+          NamespaceTestResolver
+        end
+      end
+    end
+
+    let(:resolver) do
+      resolver_class.new(message: {})
+    end
+
+    before do
+      module NamespaceTestResolver; end
+      NamespaceTestResolver::TestController = controller_class
+    end
+
+    it do
+      expect(resolver.resolve).to eq(controller: 'test', action: :some_action)
+      resolver.execute
+      expect(resolver.controller.response.to_a).to include(include(some_action: 'finished'))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+ENV['NEW_RELIC_ENV'] = 'test'
+
+require 'bundler'
+Bundler.require
+require './lib/eureka-bot'
+require 'webmock/rspec'
+EurekaBot::Job.queue_adapter = :inline
+
+$:.unshift File.dirname(__FILE__) + '/..'
+Dir['spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.include SettingsHelper
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+  # config.warnings = true
+
+  config.profile_examples = 10
+  config.order            = :random
+
+  Kernel.srand config.seed
+end

data/spec/support/settings_helper.rb

@@ -0,0 +1,5 @@
+module SettingsHelper
+  def settings
+    @settings ||= YAML.load_file('config/config.yml')['test']
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: eureka-bot
+version: !ruby/object:Gem::Version
+  version: 1.0.16
+platform: ruby
+authors:
+- Yury Alexandrov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+description: 
+email:
+- dizeru@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- eureka-bot.gemspec
+- lib/eureka-bot.rb
+- lib/eureka_bot/controller.rb
+- lib/eureka_bot/controller/response.rb
+- lib/eureka_bot/exceptions.rb
+- lib/eureka_bot/instrumentation.rb
+- lib/eureka_bot/integration.rb
+- lib/eureka_bot/integration/new_relic.rb
+- lib/eureka_bot/job.rb
+- lib/eureka_bot/job/input.rb
+- lib/eureka_bot/job/output.rb
+- lib/eureka_bot/notifications.rb
+- lib/eureka_bot/resolver.rb
+- lib/eureka_bot/sender.rb
+- lib/eureka_bot/version.rb
+- log/.keep
+- spec/eureka-bot/controller/response_spec.rb
+- spec/eureka-bot/controller_spec.rb
+- spec/eureka-bot/instrumentation_spec.rb
+- spec/eureka-bot/job_spec.rb
+- spec/eureka-bot/resolver_spec.rb
+- spec/spec_helper.rb
+- spec/support/settings_helper.rb
+- tmp/.keep
+homepage: https://github.com/dizer/eureka-bot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Run your messenger bots
+test_files:
+- spec/eureka-bot/controller/response_spec.rb
+- spec/eureka-bot/controller_spec.rb
+- spec/eureka-bot/instrumentation_spec.rb
+- spec/eureka-bot/job_spec.rb
+- spec/eureka-bot/resolver_spec.rb
+- spec/spec_helper.rb
+- spec/support/settings_helper.rb