activehook-server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 84018bc3b4180ed35962e80ada4d065de36bf9b8
+  data.tar.gz: 7c21445511837e69f2297417f759e4cc1bd5ff50
+SHA512:
+  metadata.gz: 5bf2dd5799e1b712bf1cc7179dae90239e51b0950d3bc97b8dcd12020da232e05bb99497f1daeff4fd8ba2d88aaac1d5762b66d60b99dfe5f3656e4491e80303
+  data.tar.gz: 1931a161cf1f3c613bf2d6eac816c04857acdec9084b6ec88b3f4165ac8652b335ef5eb87cb2692019067ce664e22058a21950a31b287b635f8a2eb560550f4a

data/.byebug_history

@@ -0,0 +1,4 @@
+c
+Activehook::Server::VERSION
+::Activehook::Server::VERSION
+c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at nsweeting@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activehook-server.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nicholas Sweeting
+
+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 @@
+# ActiveHook-Server

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/activehook-server.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activehook/server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activehook-server"
+  spec.version       = ActiveHook::Server::VERSION
+  spec.authors       = ["Nicholas Sweeting"]
+  spec.email         = ["nsweeting@gmail.com"]
+
+  spec.summary       = "Fast and simple webhook delivery microservice for Ruby."
+  spec.description   = "Fast and simple webhook delivery microservice for Ruby."
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = %w( activehook-server )
+  spec.require_paths = %w( lib )
+
+  spec.add_runtime_dependency     "redis", "~> 3.3"
+  spec.add_runtime_dependency     "connection_pool", "~> 2.2"
+  spec.add_runtime_dependency     "puma", "~> 3.4"
+  spec.add_runtime_dependency     "rack"
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "byebug", "~> 5.0"
+  spec.add_development_dependency "fakeredis", "~> 0.5"
+end

data/bin/activehook-server

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'activehook/server/version'
+require 'activehook/server'
+
+server = ActiveHook::Server::Launcher.new(ARGV)
+server.start

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "activehook/server"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/activehook/server/config.rb

@@ -0,0 +1,58 @@
+module ActiveHook
+  module Server
+    class << self
+      def configure
+        reset
+        yield(config)
+      end
+
+      def config
+        @config ||= Config.new
+      end
+
+      def reset
+        @config = nil
+        @connection_pool = nil
+      end
+    end
+
+    class Config
+      DEFAULTS = {
+        workers: 2,
+        queue_threads: 2,
+        retry_threads: 1,
+        redis_url: ENV['REDIS_URL'],
+        redis_pool: 5,
+        signature_header: 'X-Webhook-Signature'
+      }.freeze
+
+      attr_accessor :workers, :queue_threads, :retry_threads,
+                    :redis_url, :redis_pool, :signature_header
+
+      def initialize
+        DEFAULTS.each { |key, value| send("#{key}=", value) }
+      end
+
+      def worker_options
+        {
+          queue_threads: queue_threads,
+          retry_threads: retry_threads
+        }
+      end
+
+      def manager_options
+        {
+          workers: workers,
+          options: worker_options
+        }
+      end
+
+      def redis
+        {
+          size: redis_pool,
+          url: redis_url
+        }
+      end
+    end
+  end
+end

data/lib/activehook/server/errors.rb

@@ -0,0 +1,12 @@
+module ActiveHook
+  module Server
+    module Errors
+      class Config < StandardError; end
+      class Hook < StandardError; end
+      class HTTP < StandardError; end
+      class Send < StandardError; end
+      class Server < StandardError; end
+      class Worker < StandardError; end
+    end
+  end
+end

data/lib/activehook/server/hook.rb

@@ -0,0 +1,104 @@
+module ActiveHook
+  module Server
+    class Hook
+      attr_accessor :token, :uri, :id, :key, :retry_max, :retry_time, :created_at
+      attr_reader :errors, :payload
+
+      def initialize(options = {})
+        options = defaults.merge(options)
+        options.each { |key, value| send("#{key}=", value) }
+        @errors = {}
+      end
+
+      def save
+        return false unless valid?
+        save_hook
+      end
+
+      def save!
+        raise Errors::Hook, 'Hook is invalid' unless valid?
+        save_hook
+      end
+
+      def payload=(payload)
+        if payload.is_a?(String)
+          @payload = JSON.parse(payload)
+        else
+          @payload = payload
+        end
+      rescue JSON::ParserError
+        @payload = nil
+      end
+
+      def retry?
+        fail_at > Time.now.to_i
+      end
+
+      def retry_at
+        Time.now.to_i + @retry_time.to_i
+      end
+
+      def fail_at
+        @created_at.to_i + retry_max_time
+      end
+
+      def retry_max_time
+        @retry_time.to_i * @retry_max.to_i
+      end
+
+      def to_json
+        { id: @id,
+          key: @key,
+          token: @token,
+          created_at: @created_at,
+          retry_time: @retry_time,
+          retry_max: @retry_max,
+          uri: @uri,
+          payload: @payload }.to_json
+      end
+
+      def final_payload
+        { hook_id: @id,
+          hook_key: @key,
+          hook_time: @created_at,
+          hook_signature: ActiveHook.config.signature_header,
+          payload: @payload }.to_json
+      end
+
+      def signature
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), @token, final_payload)
+      end
+
+      def valid?
+        validate!
+        @errors.empty?
+      end
+
+      private
+
+      def save_hook
+        ActiveHook::Server.redis.with do |conn|
+          @id = conn.incr('ah:total_queued')
+          conn.lpush('ah:queue', to_json)
+          conn.zadd('ah:validation', @id, @key)
+        end
+      end
+
+      def defaults
+        { key: SecureRandom.uuid,
+          created_at: Time.now.to_i,
+          retry_time: 3600,
+          retry_max: 3 }
+      end
+
+      def validate!
+        @errors.merge!(token: ['must be a string.']) unless @token.is_a?(String)
+        @errors.merge!(payload: ['must be a Hash']) unless @payload.is_a?(Hash)
+        @errors.merge!(uri: ['is not a valid format.']) unless @uri =~ /\A#{URI::regexp}\z/
+        @errors.merge!(created_at: ['must be an Integer.']) unless @created_at.is_a?(Integer)
+        @errors.merge!(retry_time: ['must be an Integer.']) unless @retry_time.is_a?(Integer)
+        @errors.merge!(retry_max: ['must be an Integer.']) unless @retry_max.is_a?(Integer)
+      end
+    end
+  end
+end

data/lib/activehook/server/launcher.rb

@@ -0,0 +1,47 @@
+module ActiveHook
+  module Server
+    # Handles the start of the ActiveHook server via command line
+    #
+    class Launcher
+      def initialize(argv)
+        @argv = argv
+      end
+
+      # Parses commmand line options and starts the Manager object
+      #
+      def start
+        start_message
+        setup_options
+        boot_manager
+      end
+
+      private
+
+      def start_message
+        ActiveHook::Server.log.info('ActiveHook Server starting!')
+        ActiveHook::Server.log.info("* Version #{VERSION}, codename: #{CODENAME}")
+      end
+
+      # Parses the arguments passed through the command line.
+      #
+      def setup_options
+        parser = OptionParser.new do |o|
+          o.banner = 'Usage: bundle exec bin/activehook [options]'
+
+          o.on('-c', '--config PATH', 'Load PATH for config file') do |arg|
+            load(arg)
+            ActiveHook::Server.log.info("* Server config:  #{arg}")
+          end
+
+          o.on('-h', '--help', 'Prints this help') { puts o && exit }
+        end
+        parser.parse!(@argv)
+      end
+
+      def boot_manager
+        manager = Manager.new(ActiveHook::Server.config.manager_options)
+        manager.start
+      end
+    end
+  end
+end

data/lib/activehook/server/log.rb

@@ -0,0 +1,31 @@
+require 'logger'
+
+module ActiveHook
+  module Server
+    class << self
+      STDOUT.sync = true
+
+      def log
+        @log ||= Log.new
+      end
+    end
+
+    class Log
+      def initialize
+        @log = ::Logger.new(STDOUT)
+        @log.formatter = proc do |_severity, datetime, _progname, msg|
+          "#{msg}\n"
+        end
+      end
+
+      def info(msg)
+        @log.info("[ \e[32mOK\e[0m ] #{msg}")
+      end
+
+      def err(msg, action: :no_exit)
+        @log.info("[ \e[31mER\e[0m ] #{msg}")
+        exit 1 if action == :exit
+      end
+    end
+  end
+end

data/lib/activehook/server/manager.rb

@@ -0,0 +1,63 @@
+module ActiveHook
+  module Server
+    # The Manager controls our Worker processes. We use it to instruct each
+    # of them to start and shutdown.
+    #
+    class Manager
+      attr_accessor :workers, :options
+      attr_reader :forks
+
+      def initialize(options = {})
+        options.each { |key, value| send("#{key}=", value) }
+        @master = Process.pid
+        at_exit { shutdown }
+      end
+
+      # Instantiates new Worker objects, setting them with our options. We
+      # follow up by booting each of our Workers. Our Manager is then put to
+      # sleep so that our Workers can do their thing.
+      #
+      def start
+        validate!
+        start_messages
+        create_workers
+        Process.wait
+      end
+
+      # Shutsdown our Worker processes.
+      #
+      def shutdown
+        @forks.each { |w| Process.kill('SIGINT', w[:pid].to_i) }
+        Process.kill('SIGINT', @master)
+      end
+
+      private
+
+      # Create the specified number of workers and starts them
+      #
+      def create_workers
+        @forks = []
+        @workers.times do |id|
+          pid = fork { Worker.new(@options.merge(id: id)).start }
+          @forks << { id: id, pid: pid }
+        end
+      end
+
+      # Information about the start process
+      #
+      def start_messages
+        ActiveHook::Server.log.info("* Workers: #{@workers}")
+        ActiveHook::Server.log.info("* Threads: #{@options[:queue_threads]} queue, #{@options[:retry_threads]} retry")
+      end
+
+      # Validates our data before starting our Workers. Also instantiates our
+      # connection pool by pinging Redis.
+      #
+      def validate!
+        raise Errors::Server, 'Cound not connect to Redis.' unless ActiveHook::Server.redis.with { |c| c.ping && c.quit }
+        raise Errors::Server, 'Workers must be an Integer.' unless @workers.is_a?(Integer)
+        raise Errors::Server, 'Options must be a Hash.' unless @options.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/activehook/server/queue.rb

@@ -0,0 +1,62 @@
+module ActiveHook
+  module Server
+    # The Queue object processes any hooks that are queued into our Redis server.
+    # It will perform a 'blocking pop' on our hook list until one is added.
+    #
+    class Queue
+      def initialize
+        @done = false
+      end
+
+      # Starts our queue process. This will run until instructed to stop.
+      #
+      def start
+        until @done
+          json = retrieve_hook
+          HookRunner.new(json) if json
+        end
+      end
+
+      # Shutsdown our queue process.
+      #
+      def shutdown
+        @done = true
+      end
+
+      private
+
+      # Performs a 'blocking pop' on our redis queue list.
+      #
+      def retrieve_hook
+        json = ActiveHook::Server.redis.with { |c| c.brpop('ah:queue') }
+        json.last if json
+      end
+    end
+
+    class HookRunner
+      def initialize(json)
+        @hook = Hook.new(JSON.parse(json))
+        @post = Send.new(hook: @hook)
+        start
+      end
+
+      def start
+        @post.start
+        ActiveHook::Server.redis.with do |conn|
+          @post.success? ? hook_success(conn) : hook_failed(conn)
+        end
+      end
+
+      private
+
+      def hook_success(conn)
+        conn.incr('ah:total_success')
+      end
+
+      def hook_failed(conn)
+        conn.zadd('ah:retry', @hook.retry_at, @hook.to_json) if @hook.retry?
+        conn.incr('ah:total_failed')
+      end
+    end
+  end
+end

data/lib/activehook/server/redis.rb

@@ -0,0 +1,19 @@
+module ActiveHook
+  module Server
+    class << self
+      attr_reader :connection_pool
+
+      def redis
+        @connection_pool ||= ConnectionPool.create
+      end
+    end
+
+    class ConnectionPool
+      def self.create
+        ::ConnectionPool.new(size: ActiveHook::Server.config.redis_pool) do
+          Redis.new(url: ActiveHook::Server.config.redis_url)
+        end
+      end
+    end
+  end
+end

data/lib/activehook/server/retry.rb

@@ -0,0 +1,43 @@
+module ActiveHook
+  module Server
+    class Retry
+      def initialize
+        @done = false
+      end
+
+      def start
+        until @done
+          ActiveHook::Server.redis.with do |conn|
+            conn.watch('ah:retry') do
+              retries = retrieve_retries(conn)
+              update_retries(conn, retries)
+            end
+          end
+          sleep 2
+        end
+      end
+
+      def shutdown
+        @done = true
+      end
+
+      private
+
+      def retrieve_retries(conn)
+        conn.zrangebyscore('ah:retry', 0, Time.now.to_i)
+      end
+
+      def update_retries(conn, retries)
+        if retries.any?
+          conn.multi do |multi|
+            multi.incrby('ah:total_retries', retries.count)
+            multi.zrem('ah:retry', retries)
+            multi.lpush('ah:queue', retries)
+          end
+        else
+          conn.unwatch
+        end
+      end
+    end
+  end
+end

data/lib/activehook/server/send.rb

@@ -0,0 +1,74 @@
+module ActiveHook
+  module Server
+    class Send
+      REQUEST_HEADERS = {
+        "Content-Type" => "application/json",
+        "Accept"       => "application/json",
+        "User-Agent"   => "ActiveHook/#{VERSION}"
+      }.freeze
+
+      attr_accessor :hook
+      attr_reader :response_time, :status, :response
+
+      def initialize(options = {})
+        options.each { |key, value| send("#{key}=", value) }
+      end
+
+      def start
+        @status = post_hook
+        log_status
+      end
+
+      def uri
+        @uri ||= URI.parse(@hook.uri)
+      end
+
+      def success?
+        @status == :success
+      end
+
+      private
+
+      def post_hook
+        http = Net::HTTP.new(uri.host, uri.port)
+        measure_response_time do
+          @response = http.post(uri.path, @hook.final_payload, final_headers)
+        end
+        response_status(@response)
+      rescue
+        :error
+      end
+
+      def measure_response_time
+        start = Time.now
+        yield
+        finish = Time.now
+        @response_time = "| #{((finish - start) * 1000.0).round(3)} ms"
+      end
+
+      def response_status(response)
+        case response.code.to_i
+        when (200..204)
+          :success
+        when (400..499)
+          :bad_request
+        when (500..599)
+          :server_problems
+        end
+      end
+
+      def log_status
+        msg = "POST | #{uri} | #{status.upcase} #{response_time}"
+        if status == :success
+          ActiveHook::Server.log.info(msg)
+        else
+          ActiveHook::Server.log.err(msg)
+        end
+      end
+
+      def final_headers
+        { "X-Hook-Signature" => @hook.signature }.merge(REQUEST_HEADERS)
+      end
+    end
+  end
+end

data/lib/activehook/server/version.rb

@@ -0,0 +1,6 @@
+module ActiveHook
+  module Server
+    VERSION = '0.1.0'
+    CODENAME = 'Fat Sparrow'
+  end
+end

data/lib/activehook/server/worker.rb

@@ -0,0 +1,78 @@
+module ActiveHook
+  module Server
+    # The Worker manages our two main processes - Queue and Retry. Each of these
+    # processes is alloted a number of threads. These threads are then forked.
+    # Each worker object maintains control of these threads through the aptly
+    # named start and shutdown methods.
+    #
+    class Worker
+      attr_accessor :queue_threads, :retry_threads, :id
+
+      def initialize(options = {})
+        options.each { |key, value| send("#{key}=", value) }
+        @pid = Process.pid
+        @threads = []
+        @_threads_real = []
+        at_exit { shutdown }
+      end
+
+      # Starts our new worker.
+      #
+      def start
+        validate!
+        start_message
+        build_threads
+        start_threads
+      end
+
+      # Shutsdown our worker as well as its threads.
+      #
+      def shutdown
+        shutdown_message
+        @threads.each(&:shutdown)
+        @_threads_real.each(&:exit)
+      end
+
+      private
+
+      # Forks the worker and creates the actual threads (@_threads_real) for
+      # our Queue and Retry objects. We then start them and join them to the
+      # main process.
+      #
+      def start_threads
+        @threads.each do |thread|
+          @_threads_real << Thread.new { thread.start }
+        end
+        @_threads_real.map(&:join)
+      end
+
+      # Instantiates our Queue and Retry objects based on the number of threads
+      # specified for each process type. We store these objects as an array in
+      # @threads.
+      #
+      def build_threads
+        @queue_threads.times { @threads << Queue.new }
+        @retry_threads.times { @threads << Retry.new }
+      end
+
+      # Information about the start process
+      #
+      def start_message
+        ActiveHook::Server.log.info("* Worker #{@id} started, pid: #{@pid}")
+      end
+
+      # Information about the shutdown process
+      #
+      def shutdown_message
+        ActiveHook::Server.log.info("* Worker #{@id} shutdown, pid: #{@pid}")
+      end
+
+      # Validates our data before starting the worker.
+      #
+      def validate!
+        raise Errors::Worker, 'Queue threads must be an Integer.' unless @queue_threads.is_a?(Integer)
+        raise Errors::Worker, 'Retry threads must be an Integer.' unless @retry_threads.is_a?(Integer)
+      end
+    end
+  end
+end

data/lib/activehook/server.rb

@@ -0,0 +1,19 @@
+require 'byebug'
+require 'redis'
+require 'json'
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'connection_pool'
+require 'activehook/server/hook'
+require 'activehook/server/config'
+require 'activehook/server/redis'
+require 'activehook/server/errors'
+require 'activehook/server/log'
+require 'activehook/server/config'
+require 'activehook/server/launcher'
+require 'activehook/server/manager'
+require 'activehook/server/queue'
+require 'activehook/server/retry'
+require 'activehook/server/send'
+require 'activehook/server/worker'

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: activehook-server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicholas Sweeting
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Fast and simple webhook delivery microservice for Ruby.
+email:
+- nsweeting@gmail.com
+executables:
+- activehook-server
+extensions: []
+extra_rdoc_files: []
+files:
+- ".byebug_history"
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activehook-server.gemspec
+- bin/activehook-server
+- bin/console
+- bin/setup
+- lib/activehook/server.rb
+- lib/activehook/server/config.rb
+- lib/activehook/server/errors.rb
+- lib/activehook/server/hook.rb
+- lib/activehook/server/launcher.rb
+- lib/activehook/server/log.rb
+- lib/activehook/server/manager.rb
+- lib/activehook/server/queue.rb
+- lib/activehook/server/redis.rb
+- lib/activehook/server/retry.rb
+- lib/activehook/server/send.rb
+- lib/activehook/server/version.rb
+- lib/activehook/server/worker.rb
+homepage: 
+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.5.0
+signing_key: 
+specification_version: 4
+summary: Fast and simple webhook delivery microservice for Ruby.
+test_files: []
+has_rdoc: