consul_watcher 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84e80ff2e7d93407b1fbf14774a8cb4d585962468da5a15e8c491a22408d3de9
-  data.tar.gz: 227c86658315bcbe920e6110b3818a3a7879b7899809c5f095293d085d7656e7
+  metadata.gz: 9e50318d48e6289402eb0458fe4e4223a548810de65f592400dc3e7012f4443b
+  data.tar.gz: 4e25cb74e2e614f9a874aa07a9e8627a2733233cc3503ebb61ea4bc94a09afcd
 SHA512:
-  metadata.gz: 992881948d116b0ef750143056cc2d0595ea25795c6866e69ff3c28910d9939383f8eaf468401146a6e403fd5cfa39c294261141d1716253471dd3b2c0c2ec20
-  data.tar.gz: 9c6eaf4fd1c6c1e98eba0e2f640d83cb602e064de618cdc57280bd50a5a0f0bf7d2a15c6b4415474f7a33adf99d3b65c6039d609a6919eebb0d3bf3921c0c372
+  metadata.gz: a5e77b1018fce3771ccc803f0341067761ea55bfb19330332f9152d9beef7ad47971ca3a28e61e56b787ee7b9b902bdb898177b08c598083efdbf3858fb5885c
+  data.tar.gz: 18fac72357f24ab0e88516c79439fcef5bab11cc1c7f766e03dc63ace7897ed8c30c673706c3cfcf2bc363c8bee9ced936255f200c339fb8e6a1aca671d716c7

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.0.2
+
+### New Functionality
+- Adding loggers to classes
+- Classes now use class helper to initialize variables
+- Added rake tasks for standing up local testing cluster `rake up`
+- Updated message formats.  Messages now have `id` and `change_type` fields
+- Added Consul backend storage for json diffs
+
+### TODO for 0.1.0 release
+- Finalize Key Watch functionality
+- Finalize Consul Storage functionality
+- Finalize AMQP Destination functionality
+- Add rspec tests
+- Rake tasks to manage releases
+- Update documentation
+

data/README.md

@@ -1,6 +1,9 @@
 # NOTICE
 This gem is a work in progress.  Please see the [TODO](https://github.com/fortman/consul_watcher/blob/master/docs/TODO.md) documentation
 
+## First 0.0.1 release.  Partial functionality
+- [ruby gem](https://rubygems.org/gems/consul_watcher)
+- [docker image](https://cloud.docker.com/repository/docker/rfortman/consul_watcher)
 
 ## Note on naming
 This project name is a little confusing in that it called `consul_watcher`.  It is wrapping the `consul watch` command line tool from Hashicorp.  To avoid confusion, this project in the context of both the docker image and ruby gem will be referred to as `consul_watcher`.  Any time that `consul watch` is used, that is a reference to the actualy Hashicorp command.
@@ -10,6 +13,7 @@ This git project produces a docker image.  The basic premise of this docker imag
 * parse the json output of the [consul watch](https://www.consul.io/docs/commands/watch.html) command
 * compare the output to the previous consul watch output
 * send the diff to a destination
+
 The primary destination at this time is an AMQP topic exchange.  The underlying logic in the docker image is a ruby gem.  To make the gem modular and extensible, the functionality has been broken up into 3 sections; storage, watch_type, and destination.
 
 If we want to do a diff of consul watches, we need to store the previous consul watch json.  This is because consul watches kick off new executions on every change, so we can't store the previous run in memory.  Storage is accomplished with [storage classes](https://github.com/fortman/consul_watcher/blob/master/docs/storage/storage.md).  The purpose of the storage class is to just store and retrieve previous consul watch json.  At this time, backend storage is planned for both local filesystem, and consul kv storage.

data/Rakefile

@@ -2,6 +2,7 @@
 
 require 'bundler/gem_tasks'
 require 'open3'
+require_relative 'lib/consul_watcher/rake_helper'
 
 spec_file = Gem::Specification.load('consul_watcher.gemspec')
 
@@ -39,17 +40,25 @@ task docker_build: [:build] do
   end
 end
 
-task :test do
-  build_cmd = 'docker-compose --file test/docker-compose.yml up rabbitmq consul consul-watcher'
-  threads = []
-  Open3.popen3(build_cmd) do |_stdin, stdout, stderr, wait_thr|
-    { out: stdout, err: stderr }.each do |key, stream|
-      threads << Thread.new do
-        until (raw_line = stream.gets).nil?
-          puts raw_line.to_s
-        end
-      end
-    end
-    threads.each(&:join)
-  end
+task :start_deps do
+  cmd = 'docker-compose --file test/docker-compose.yml up -d consul rabbitmq'
+  ConsulWatcher::RakeHelper.exec(cmd)
+  urls = [
+    'http://localhost:8500/v1/status/leader',
+    'http://localhost:15672'
+  ]
+  ConsulWatcher::RakeHelper.wait_for_urls(urls)
+  ConsulWatcher::RakeHelper.config_rabbitmq
+end
+
+task up: [:start_deps] do
+  cmd = 'docker-compose --file test/docker-compose.yml up -d consul-watcher'
+  _output, _status = ConsulWatcher::RakeHelper.exec(cmd)
+  puts 'Starting queue consumer'
+  ConsulWatcher::RakeHelper.consumer_start
+end
+
+task :down do
+  cmd = 'docker-compose --file test/docker-compose.yml down'
+  _output, _status = ConsulWatcher::RakeHelper.exec(cmd)
 end

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/consul_watcher.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   # spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_runtime_dependency 'bundler', '~> 2.0'
+  spec.add_runtime_dependency 'diplomat', '~> 2.2.4'
   spec.add_dependency 'bunny', '~> 1.7.0'
   spec.add_dependency 'hashdiff', '~> 0.3'
   spec.add_dependency 'slop', '~> 4.6'

data/docs/docker-quickstart.md

@@ -2,14 +2,15 @@
 
 The easiest way to get started with consul_watcher is with the docker image.  The docker entry point will run a consul watch and then pipe the output to the ruby consul_watcher program.  The behavior is mostly driven by passing environmental variables into docker.  Environmental variables, command line parameters and a configuration file are being tested to determine which is best way to configure consul_watch.  There is a docker compose file to test things out locally  The following steps should have you working with a local cluster fairly quick.  A rake task will be created to automate these steps at some point.
 
-From the root of the git repository execute the following<br/>
-:> `docker-compose --file test/docker-compose.yml up --no-start`<br/>
-:> `docker-compose --file test/docker-compose.yml start consul rabbitmq`<br/>
-Wait a bit of time for those services to start.  30 seconds should suffice.<br/>
-Login to rabbitmq locally http://localhost:15672. Use guest/guest as password.  <br/>
-Create a queue and bind it to the amq.topic exchange.  Use routing key `consul_watcher.key.#` for the bind.<br/>
-:> `docker-compose --file test/docker-compose.yml start consul-watcher`<br/>
-Login to consul locally http://localhost:8500.  You should be able to start creating, updating and deleting entries in the kv store.  Go back to rabbitmq and you should be seeing messages in the queue you created.<br/>
+You can build and run the stack locally with the following steps:
+
+From the root of the git repository execute these rake tasks<br/>
+:> `rake`<br/>
+:> `rake up`<br/>
+
+You will have a locally running consul and rabbitmq instance.  Rabbitmq will already have a queue bound to the appropriate exchange.  The terminal where you ran `rake up` will show any key/value changes you make in consul.
+
+After the docker containers have started, you can login to consul locally http://localhost:8500.  You should be able to start creating, updating and deleting entries in the kv store.  Go back to rabbitmq and you should be seeing messages flowing through the queue as you make updates in consul.<br/>
 
 # environmental variables used by docker image
 | environment variable | description                                                         | example value                                                                                               |

data/exe/consul_watcher

@@ -10,8 +10,6 @@ require 'consul_watcher'
 logger = Logger.new(STDOUT)
 
 opts = Slop.parse do |o|
-  o.string '--watch-type', required: true
-  o.string '--storage-name', required: true
   o.string '--config-file', required: true
   o.on '-h', '--help', 'print help' do
     logger.warn("\n#{o}")
@@ -21,4 +19,5 @@ end
 
 config = JSON.parse(File.read(opts['config-file']))
 
-ConsulWatcher.watch(opts['watch-type'], opts['storage-name'], config)
+# ConsulWatcher.watch(opts['watch-type'], config)
+ConsulWatcher.watch(config)

data/lib/consul_watcher.rb

@@ -4,38 +4,48 @@
 
 require 'json'
 require 'hashdiff'
+require 'consul_watcher/filters'
 
 # Top Level module to run watch logic
 module ConsulWatcher
-  def self.watch(watch_type, storage_name, config)
-    storage = get_storage(config['storage']) if config['storage']
-    watch_type = get_watch_type(config['watch_type']) if config['watch_type']
-    filters = get_filters(config['filters']) if config['filters']
-    destination = get_destination(config['destination']) if config['destination']
-
+  def self.watch(config)
+    #Encoding.default_external = Encoding::UTF_8
+    #Encoding.default_external = Encoding::ASCII_8BIT
+    assemble(config)
     current_watch_json = $stdin.read
-    previous_watch_json = storage.fetch(storage_name)
-    changes = watch_type.get_changes(previous_watch_json, current_watch_json)
+    previous_watch_json = @storage.fetch
+    changes = @watch_type.get_changes(previous_watch_json, current_watch_json)
     changes.each do |change|
-      destination.send(change)
+      @destination.send(change)
     end
-    storage.push(storage_name, current_watch_json)
+    @storage.push(current_watch_json) unless changes.empty?
+  end
+
+  private
+
+  def self.assemble(config)
+    @storage = get_storage(config['storage'])
+    @watch_type = get_watch_type(config['watch_type'])
+    @destination = get_destination(config['destination'])
+    
+    @watch_type.filters = ConsulWatcher::Filters.new(config['watch_type'] || {})
+    @watch_type.filters.add_filters(@storage.get_filters)
   end
 
   def self.get_storage(storage_config)
-    classname = storage_config['classname'] || 'ConsulWatcher::Storage::Disk'
+    classname = storage_config['classname']
     require classname_to_file(classname)
     Object.const_get(classname).new(storage_config)
   end
 
   def self.get_watch_type(watch_type_config)
-    classname = watch_type_config['classname'] || 'ConsulWatcher::WatchType::Checks'
+    classname = watch_type_config['classname']
     require classname_to_file(classname)
     Object.const_get(classname).new(watch_type_config)
   end
 
   def self.get_destination(destination_config)
-    classname = destination_config['classname'] || 'ConsulWatcher::Destination::Jq'
+    classname = destination_config['classname']
     require classname_to_file(classname)
     Object.const_get(classname).new(destination_config)
   end

data/lib/consul_watcher/destination/amqp.rb

@@ -1,28 +1,59 @@
 # frozen_string_literal: true
 
 require 'bunny'
+require 'consul_watcher/class_helper'
+require 'json'
 
 module ConsulWatcher
   module Destination
     # Send diff output to jq command line
     class Amqp
+      include ClassHelper
+
       def initialize(destination_config)
-        @conn = Bunny.new(host: destination_config['rabbitmq']['server'] || 'localhost',
-                          port: destination_config['rabbitmq']['port'] || '5672',
-                          vhost: destination_config['rabbitmq']['vhost'] || '/',
-                          username: destination_config['rabbitmq']['username'] || 'guest',
-                          password: destination_config['rabbitmq']['password'] || 'guest')
+        populate_variables(destination_config)
+        setup_rabbitmq
+      end
+
+      def setup_rabbitmq
+        @conn = Bunny.new(host: @rabbitmq_server,
+                          port: @rabbitmq_port,
+                          vhost: @rabbitmq_vhost,
+                          username: @rabbitmq_username,
+                          password: @rabbitmq_password)
         @conn.start
         @ch = @conn.create_channel
         @ex = Bunny::Exchange.new(@ch,
                                   :topic,
-                                  destination_config['rabbitmq']['exchange'] || 'amq.topic',
+                                  @rabbitmq_exchange,
                                   durable: true)
       end
 
       def send(change)
-        puts 'publishing message'
-        @ex.publish(change, routing_key: "consul_watcher.#{change['id']}")
+        @logger.debug('publishing message')
+        routing_key = change['id']
+        @logger.debug("routing_key: #{routing_key}")
+        begin
+          @ex.publish(JSON.pretty_generate(change), routing_key: change['id'])
+        rescue Encoding::UndefinedConversionError
+          change['forced_utf8'] = true
+          data = change.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+          @ex.publish(JSON.pretty_generate(data), routing_key: change['id'])
+        end
+      end
+
+      def defaults
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::DEBUG
+        {
+          logger: logger,
+          rabbitmq_server: 'localhost',
+          rabbitmq_port: '5672',
+          rabbitmq_vhost: '/',
+          rabbitmq_username: 'guest',
+          rabbitmq_password: 'guest',
+          rabbitmq_exchange: 'amq.topic'
+        }
       end
     end
   end

data/lib/consul_watcher/destination/jq.rb

@@ -1,27 +1,44 @@
 # frozen_string_literal: true
 
 require 'open3'
+require 'logger'
 
 module ConsulWatcher
   module Destination
     # Send diff output to jq command line
     class Jq
       def initialize(destination_config)
+        populate_variables(destination_config)
       end
 
       def send(change)
         change_json = JSON.pretty_generate(change)
         Open3.popen3("/usr/bin/env jq '.'") do |stdin, stdout, stderr, wait_thr|
-          stdin.puts "#{change_json}\r\n"
-          stdin.close
-          error = stderr.read
-          stderr.close
-          puts stdout.read
-          stdout.close
-          puts error unless wait_thr.value.success?
-          puts
+          { out: stdout, err: stderr }.each do |_key, stream|
+            threads << Thread.new do
+              until (raw_line = stream.gets).nil?
+                output << raw_line.to_s
+                @logger.info(raw_line.to_s) if stream
+              end
+            end
+          end
+          threads.each(&:join)
+          status = wait_thr.value.success?
         end
       end
+
+      def defaults
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::INFO
+        {
+          logger: logger,
+          rabbitmq_server: 'localhost',
+          rabbitmq_port: '5672',
+          rabbitmq_vhost: '/',
+          rabbitmq_username: 'guest',
+          rabbitmq_password: 'guest',
+          rabbitmq_exchange: 'amq.topic'
+        }
     end
   end
 end

data/lib/consul_watcher/diff.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'hashdiff'
-require 'logger'
 
 module ConsulWatcher
   class Diff
@@ -10,10 +9,8 @@ module ConsulWatcher
     def parse(previous_watch_data, current_watch_data)
       diff = HashDiff.diff(sanitize_data(previous_watch_data), sanitize_data(current_watch_data), array_path: true)
       diff.each do |change|
-        puts "change: #{change}"
         change[1] = change[1]&.join('/')
       end
-      puts "hashdiff: #{diff}"
       diff
     end
 

data/lib/consul_watcher/filters.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'consul_watcher/class_helper'
+
+module ConsulWatcher
+  class Filters
+    include ClassHelper
+
+    def initialize(filter_config)
+      populate_variables(filter_config)
+    end
+
+    def add_filters(filters_to_add)
+      @filters.merge!(filters_to_add)
+    end
+
+    def filter?(change)
+      @filters.each do |attribute, regex|
+        match = change.key?(attribute) ? change[attribute].match?(/#{regex}/) : false
+        if match
+          @logger.debug("filtered #{change['id']} #{attribute} on regex #{regex}")
+          return true 
+        end
+      end
+      false
+    end
+
+    def print_filters
+      @filters.each do |filter|
+        @logger.debug("filter: #{filter}")
+      end
+    end
+
+    private
+
+    def defaults
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::WARN
+      {
+        logger: logger,
+        filters: {}
+      }
+    end
+  end
+end

data/lib/consul_watcher/rake_helper.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require 'open3'
+require 'net/http'
+require 'bunny'
+require 'json'
+
+module ConsulWatcher
+  module RakeHelper
+    def self.exec(command, stream: true)
+      output = [] ; threads = [] ; status = nil
+      Open3.popen3(command) do |_stdin, stdout, stderr, wait_thr|
+        { out: stdout, err: stderr }.each do |_key, stream|
+          threads << Thread.new do
+            until (raw_line = stream.gets).nil?
+              output << raw_line.to_s
+              puts raw_line.to_s if stream
+            end
+          end
+        end
+        threads.each(&:join)
+        status = wait_thr.value.success?
+      end
+      return output, status
+    end
+
+    def self.wait_for_urls(urls)
+      urls.each do |url|
+        uri = URI(url)
+        error = true
+        Net::HTTP.start(uri.host, uri.port, read_timeout: 5, max_retries: 12) do |http|
+          while error
+            begin
+              response = http.request(Net::HTTP::Get.new(uri))
+              error = false
+            rescue EOFError
+              retry
+            end
+          end
+          raise Exception unless response.code == '200'
+
+          puts "up: #{url}"
+        end
+      end
+    end
+
+    def self.config_rabbitmq
+      conn = Bunny.new(host: 'localhost', port: '5672', vhost: '/', \
+                       username: 'guest', password: 'guest')
+      conn.start
+      ch = conn.create_channel
+      ex = Bunny::Exchange.new(ch, :topic, 'amq.topic', durable: true)
+      @queue = ch.queue('consul_watcher', durable: true).bind(ex, routing_key: 'consul_watcher.key.#')
+      nil
+    end
+
+    def self.process_message(delivery_info, properties, body)
+      puts "routing_key: #{delivery_info[:routing_key]}"
+      puts "properties: #{properties}"
+      puts "body:\n#{body}"
+      puts
+    end
+
+    def self.consumer_start
+      @consumer ||= @queue.subscribe(block: true, &itself.method(:process_message))
+      nil
+    end
+
+    def self.consumer_stop
+      @consumer&.cancel
+      @consumer = nil
+    end
+  end
+end

data/lib/consul_watcher/storage/consul.rb

@@ -1,13 +1,66 @@
 # frozen_string_literal: true
 
+require 'diplomat'
+require 'consul_watcher/class_helper'
+require 'zlib'
+
 # This will be a module to store previous consul watch json to compare with previous watch data
 module ConsulWatcher
   module Storage
     # Consul storage for previous watch data
-    class Disk
+    class Consul
+      include ClassHelper
+
       def initialize(storage_config)
-        @parent_dir = storage_config['storage_parent_dir'] || '/tmp'
+        populate_variables(storage_config)
+        config_diplomat
+      end
+
+      def fetch
+        @logger.debug('fetching state from consul')
+        data = Diplomat::Kv.get(cache_file_name)
+        data = Zlib::Inflate.inflate(data) if @encrypt
+        data
+      rescue Diplomat::KeyNotFound
+        '{}'
+      end
+
+      def push(data)
+        @logger.debug('pushing state to consul')
+        Diplomat::Kv.put(cache_file_name, @encrypt ? Zlib::Deflate.deflate(data, Zlib::BEST_COMPRESSION) : data)
+      end
+
+      def get_filters
+        { 'key_path' => cache_file_name }
+      end
+
+      private
+
+      def cache_file_name
+        "#{@parent_dir}/#{@storage_name}"
+      end
+
+      def config_diplomat
+        Diplomat.configure do |config|
+          # Set up a custom Consul URL
+          config.url = @consul_http_addr
+          # Set extra Faraday configuration options and custom access token (ACL)
+          config.options = {headers: {"X-Consul-Token" => @consul_token}}
+        end
+      end
+
+      def defaults
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::WARN
+        {
+          logger: logger,
+          storage_name: 'kv',
+          parent_dir: 'watch/json-store',
+          consul_http_addr: 'http://localhost:8500',
+          consul_token: nil,
+          encrypt: false
+        }
       end
     end
   end
-end
+end

data/lib/consul_watcher/watch_type/key.rb

@@ -1,31 +1,48 @@
 # frozen_string_literal: true
 
 require 'base64'
+require 'consul_watcher/class_helper'
 
 module ConsulWatcher
   module WatchType
     class Key
-      def initialize(destination_config) end
+      include ClassHelper
+
+      attr_accessor :filters
+      def initialize(watch_config)
+        populate_variables(watch_config)
+      end
 
       def get_changes(previous_watch_json, current_watch_json)
-        json_diff = HashDiff.diff(json_to_hash(previous_watch_json),
+        json_diff = get_diff(previous_watch_json, current_watch_json)
+
+        changes = json_diff.each.collect do |change|
+          formatted_change = format_change('key', change)
+          decode(formatted_change) if @decode_values
+          formatted_change
+        end.compact
+        changes = changes.each.collect.reject {|change| @filters.filter?(change)}
+        changes
+      end
+
+      def filters=(f)
+        @filters = f
+      end
+
+      private
+      def get_diff(previous_watch_json, current_watch_json)
+         HashDiff.diff(json_to_hash(previous_watch_json),
                                   json_to_hash(current_watch_json),
                                   array_path: true)
-        json_diff.each.collect do |change|
-          # change[1] = change[1].join('/')
-          change[2] = Base64.decode64(change[2]) if change[2].is_a? String
-          change[3] = Base64.decode64(change[3]) if change[3].is_a? String
-          { 
-            'watch_type' => 'key',
-            'id' => id(change),
-            'diff' => change
-          }
-        end
-        #json_diff.reject { |change| change[0] == '~' && change[1][-1] == 'ModifyIndex' }
       end
 
-      def id(change)
-        "key.#{change[1][0].tr('/', '.')}"
+      def decode(change)
+        return unless change['element'] == 'Value'
+
+        change['old_value'] = Base64.decode64(change['old_value']) if change['old_value'].is_a? String
+        change['new_value'] = Base64.decode64(change['new_value']) if change['new_value'].is_a? String
+        change['new_value']['Value'] = Base64.decode64(change['new_value']['Value']) if change['change_type'] == '+' && change['new_value']['Value'].is_a?(String)
+        change['old_value']['Value'] = Base64.decode64(change['old_value']['Value']) if change['change_type'] == '-' && change['old_value']['Value'].is_a?(String)
       end
 
       def json_to_hash(json)
@@ -34,7 +51,35 @@ module ConsulWatcher
           { kv['Key'] => kv.reject { |key, _value| key == 'Key' } }
         end.reduce({}, :merge)
       end
-      
+
+      def format_change(watch_type, change)
+        old_value, new_value = change_values(change)
+        {
+          'id' => "consul_watcher.key.#{change[1][0].tr('/', '.')}",
+          'watch_type' => watch_type,
+          'key_path' =>  change[1][0],
+          'key_property' => change[1][1],
+          'old_value' => old_value,
+          'new_value' => new_value
+        }
+      end
+
+      def routing_key(change)
+      end
+
+      def change_values(change)
+        # Return old_value, new_value
+        return nil, change[2] if change[0] == '+'
+        return change[2], nil if change[0] == '-'
+        return change[2], change[3] if change[0] == '~'
+      end
+
+      def defaults
+        {
+          watch_type: 'key',
+          decode_values: true
+        }
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: consul_watcher
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ryan Fortman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-14 00:00:00.000000000 Z
+date: 2019-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: diplomat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.4
 - !ruby/object:Gem::Dependency
   name: bunny
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +103,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- CHANGELOG.md
 - Dockerfile
 - Gemfile
 - README.md
@@ -118,6 +133,8 @@ files:
 - lib/consul_watcher/destination/amqp.rb
 - lib/consul_watcher/destination/jq.rb
 - lib/consul_watcher/diff.rb
+- lib/consul_watcher/filters.rb
+- lib/consul_watcher/rake_helper.rb
 - lib/consul_watcher/storage/consul.rb
 - lib/consul_watcher/storage/disk.rb
 - lib/consul_watcher/watch_type/checks.rb