logstash-input-redis-cluster 2.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c753cc2def1e0233efa5a49a580159d4ba2aa9f
+  data.tar.gz: e47850e128dee3d7f6a379bd2aaf25cafdeed534
+SHA512:
+  metadata.gz: f9a25fffed1c8b9f601e967546e17f81cb1e36d00869aa3ccc3fc1d4cc618cc749abd1eb88f97c95f1941893032b9139af36ad33feb611e12566d3579dcfc580
+  data.tar.gz: b0e9d2d6c56d4b80625d922b87140fb195ae8d5f4a7c1f5ff0537e31e420487d65475637859c8015a6ec67b990647d4ecc6cb513b75d68d0d8a4b00c9088fc7b

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 2.0.0
+ - Plugins were updated to follow the new shutdown semantic, this mainly allows Logstash to instruct input plugins to terminate gracefully, 
+   instead of using Thread.raise on the plugins' threads. Ref: https://github.com/elastic/logstash/pull/3895
+ - Dependency on logstash-core update to 2.0
+
+## 1.0.3
+ - Fix typo in module name in test (Causing CI build failures)
+
+ ## 1.0.2
+ - Fix typo in module name (Causing the module to not be loaded)
+
+## 1.0.1
+ - Make teardown more reliable
+ - Re-organise code and tests

data/CONTRIBUTORS

@@ -0,0 +1,21 @@
+The following is a list of people who have contributed ideas, code, bug
+reports, or in general have helped logstash along its way.
+
+Contributors:
+* Aaron Mildenstein (untergeek)
+* Bob Corsaro (dokipen)
+* Colin Surprenant (colinsurprenant)
+* Graham Bleach (bleach)
+* Jason Woods (driskell)
+* John E. Vincent (lusis)
+* Jordan Sissel (jordansissel)
+* Kurt Hurtado (kurtado)
+* Pete Fritchman (fetep)
+* Pier-Hugues Pellerin (ph)
+* Richard Pijnenburg (electrical)
+* piavlo
+
+Note: If you've sent us patches, bug reports, or otherwise contributed to
+Logstash, and you aren't on the list above and want to be, please let us know
+and we'll make sure you're here. Contributions from folks like you are what make
+open source awesome.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+gemspec
+gem "redis-rb-cluster", :git => "git://github.com/Tschef/redis-rb-cluster.git"

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012–2015 Elasticsearch <http://www.elastic.co>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/NOTICE.TXT

@@ -0,0 +1,5 @@
+Elasticsearch
+Copyright 2012-2015 Elasticsearch
+
+This product includes software developed by The Apache Software
+Foundation (http://www.apache.org/).

data/README.md

@@ -0,0 +1,86 @@
+# Logstash Plugin
+
+This is a plugin for [Logstash](https://github.com/elastic/logstash).
+
+It is fully free and fully open source. The license is Apache 2.0, meaning you are pretty much free to use it however you want in whatever way.
+
+## Documentation
+
+Logstash provides infrastructure to automatically generate documentation for this plugin. We use the asciidoc format to write documentation so any comments in the source code will be first converted into asciidoc and then into html. All plugin documentation are placed under one [central location](http://www.elastic.co/guide/en/logstash/current/).
+
+- For formatting code or config example, you can use the asciidoc `[source,ruby]` directive
+- For more asciidoc formatting tips, see the excellent reference here https://github.com/elastic/docs#asciidoc-guide
+
+## Need Help?
+
+Need help? Try #logstash on freenode IRC or the https://discuss.elastic.co/c/logstash discussion forum.
+
+## Developing
+
+### 1. Plugin Developement and Testing
+
+#### Code
+- To get started, you'll need JRuby with the Bundler gem installed.
+
+- Create a new plugin or clone and existing from the GitHub [logstash-plugins](https://github.com/logstash-plugins) organization. We also provide [example plugins](https://github.com/logstash-plugins?query=example).
+
+- Install dependencies
+```sh
+bundle install
+```
+
+#### Test
+
+- Update your dependencies
+
+```sh
+bundle install
+```
+
+- Run tests
+
+```sh
+bundle exec rspec
+```
+
+### 2. Running your unpublished Plugin in Logstash
+
+#### 2.1 Run in a local Logstash clone
+
+- Edit Logstash `Gemfile` and add the local plugin path, for example:
+```ruby
+gem "logstash-filter-awesome", :path => "/your/local/logstash-filter-awesome"
+```
+- Install plugin
+```sh
+bin/plugin install --no-verify
+```
+- Run Logstash with your plugin
+```sh
+bin/logstash -e 'filter {awesome {}}'
+```
+At this point any modifications to the plugin code will be applied to this local Logstash setup. After modifying the plugin, simply rerun Logstash.
+
+#### 2.2 Run in an installed Logstash
+
+You can use the same **2.1** method to run your plugin in an installed Logstash by editing its `Gemfile` and pointing the `:path` to your local plugin development directory or you can build the gem and install it using:
+
+- Build your plugin gem
+```sh
+gem build logstash-filter-awesome.gemspec
+```
+- Install the plugin from the Logstash home
+```sh
+bin/plugin install /your/local/plugin/logstash-filter-awesome.gem
+```
+- Start Logstash and proceed to test the plugin
+
+## Contributing
+
+All contributions are welcome: ideas, patches, documentation, bug reports, complaints, and even something you drew up on a napkin.
+
+Programming is not a required skill. Whatever you've seen about open source and maintainers or community members  saying "send patches or die" - you will not see that here.
+
+It is more important to the community that you are able to contribute.
+
+For more information about contributing, see the [CONTRIBUTING](https://github.com/elastic/logstash/blob/master/CONTRIBUTING.md) file.

data/lib/logstash/inputs/redis_cluster.rb

@@ -0,0 +1,330 @@
+# encoding: utf-8
+require "logstash/namespace"
+require "logstash/inputs/base"
+require "logstash/inputs/threadable"
+
+# This input will read events from a Redis instance; it supports both Redis channels and lists.
+# The list command (BLPOP) used by Logstash is supported in Redis v1.3.1+, and
+# the channel commands used by Logstash are found in Redis v1.3.8+.
+# While you may be able to make these Redis versions work, the best performance
+# and stability will be found in more recent stable versions.  Versions 2.6.0+
+# are recommended.
+#
+# For more information about Redis, see <http://redis.io/>
+#
+# `batch_count` note: If you use the `batch_count` setting, you *must* use a Redis version 2.6.0 or
+# newer. Anything older does not support the operations used by batching.
+#
+module LogStash module Inputs class RedisCluster < LogStash::Inputs::Threadable
+# class LogStash::Inputs::Redis < LogStash::Inputs::Threadable
+
+  config_name "redis_cluster"
+
+  default :codec, "json"
+
+  # The `name` configuration is used for logging in case there are multiple instances.
+  # This feature has no real function and will be removed in future versions.
+  config :name, :validate => :string, :default => "default", :deprecated => true
+
+  # The hostname of your Redis server.
+  config :host, :validate => :string, :default => "127.0.0.1"
+
+  # The port to connect on.
+  config :port, :validate => :number, :default => 6379
+
+  # The Redis database number.
+  config :db, :validate => :number, :default => 0
+
+  # Initial connection timeout in seconds.
+  config :timeout, :validate => :number, :default => 5
+
+  # Password to authenticate with. There is no authentication by default.
+  config :password, :validate => :password
+
+  # The name of a Redis list or channel.
+  # TODO: change required to true
+  config :keys, :validate => :array
+
+  # Specify either list or channel.  If `redis\_type` is `list`, then we will BLPOP the
+  # key.  If `redis\_type` is `channel`, then we will SUBSCRIBE to the key.
+  # If `redis\_type` is `pattern_channel`, then we will PSUBSCRIBE to the key.
+  # TODO: change required to true
+  config :data_type, :validate => [ "list", "channel", "pattern_channel" ], :required => false
+
+  # The number of events to return from Redis using EVAL.
+  config :batch_count, :validate => :number, :default => 1
+
+  public
+  # public API
+  # use to store a proc that can provide a redis instance or mock
+  def add_external_redis_builder(builder) #callable
+    @redis_builder = builder
+    self
+  end
+
+  # use to apply an instance directly and bypass the builder
+  def use_redis(instance)
+    @redis = instance
+    self
+  end
+
+  def new_redis_instance
+    @redis_builder.call
+  end
+
+  def register
+    require 'redis-rb-cluster'
+    @redis_url = "redis://#{@password}@#{@host}:#{@port}/#{@db}"
+
+    # TODO remove after setting key and data_type to true
+   
+    if !@keys || !@data_type
+      raise RuntimeError.new(
+        "Must define queue, or key and data_type parameters"
+      )
+    end
+    # end TODO
+
+    @redis_builder ||= method(:internal_redis_builder)
+
+    # just switch on data_type once
+    if @data_type == 'list' || @data_type == 'dummy'
+      @run_method = method(:list_runner)
+      @stop_method = method(:list_stop)
+    elsif @data_type == 'channel'
+      @run_method = method(:channel_runner)
+      @stop_method = method(:subscribe_stop)
+    elsif @data_type == 'pattern_channel'
+      @run_method = method(:pattern_channel_runner)
+      @stop_method = method(:subscribe_stop)
+    end
+
+    # TODO(sissel, boertje): set @identity directly when @name config option is removed.
+    @identity = @name != 'default' ? @name : "#{@redis_url} #{@data_type}"
+    @logger.info("Registering Redis", :identity => @identity)
+  end # def register
+
+  def run(output_queue)
+    @run_method.call(output_queue)
+  rescue LogStash::ShutdownSignal
+    # ignore and quit
+  end # def run
+
+  def stop
+    @stop_method.call
+  end
+
+  # private methods -----------------------------
+  private
+
+  def batched?
+    @batch_count > 1
+  end
+
+  # private
+  def is_list_type?
+    @data_type == 'list'
+  end
+
+  # private
+  def redis_params
+    {
+      :host => @host,
+      :port => @port,
+      :timeout => @timeout,
+      :db => @db,
+      :password => @password.nil? ? nil : @password.value
+    }
+  end
+
+  # private
+  def internal_redis_builder
+    ::RedisCluster.new([redis_params],4)
+  end
+
+  # private
+  def connect
+    redis = new_redis_instance
+    load_batch_script(redis) if batched? && is_list_type?
+    redis
+  end # def connect
+
+  # private
+  def load_batch_script(redis)
+    #A Redis Lua EVAL script to fetch a count of keys
+    #in case count is bigger than current items in queue whole queue will be returned without extra nil values
+    redis_script = <<EOF
+          local i = tonumber(ARGV[1])
+          local res = {}
+          local length = redis.call('llen',KEYS[1])
+          if length < i then i = length end
+          while (i > 0) do
+            local item = redis.call("lpop", KEYS[1])
+            if (not item) then
+              break
+            end
+            table.insert(res, item)
+            i = i-1
+          end
+          return res
+EOF
+    @redis_script_sha = redis.script(:load, redis_script)
+  end
+
+  # private
+  def queue_event(msg, output_queue)
+    begin
+      @codec.decode(msg) do |event|
+        decorate(event)
+        output_queue << event
+      end
+    rescue => e # parse or event creation error
+      @logger.error("Failed to create event", :message => msg, :exception => e, :backtrace => e.backtrace);
+    end
+  end
+
+  # private
+  def list_stop
+    return if @redis.nil? || !@redis.connected?
+
+    @redis.quit rescue nil
+    @redis = nil
+  end
+
+  # private
+  def list_runner(output_queue)
+    while !stop?
+      begin
+        @redis ||= connect
+        list_listener(@redis, output_queue)
+      rescue ::Redis::BaseError => e
+        @logger.warn("Redis connection problem", :exception => e)
+        # Reset the redis variable to trigger reconnect
+        @redis = nil
+        # this sleep does not need to be stoppable as its
+        # in a while !stop? loop
+        sleep 1
+      end
+    end
+  end
+
+  # private
+  def list_listener(redis, output_queue)
+	sampled = @keys.sample
+    item = redis.blpop(sampled, :timeout => 1)
+    return unless item # from timeout or other conditions
+
+    # blpop returns the 'key' read from as well as the item result
+    # we only care about the result (2nd item in the list).
+    queue_event(item.last, output_queue)
+
+    # If @batch_count is 1, there's no need to continue.
+    return if !batched?
+
+    begin
+      redis.evalsha(@redis_script_sha, [sampled], [@batch_count-1]).each do |item|
+        queue_event(item, output_queue)
+      end
+
+      # Below is a commented-out implementation of 'batch fetch'
+      # using pipelined LPOP calls. This in practice has been observed to
+      # perform exactly the same in terms of event throughput as
+      # the evalsha method. Given that the EVALSHA implementation uses
+      # one call to Redis instead of N (where N == @batch_count) calls,
+      # I decided to go with the 'evalsha' method of fetching N items
+      # from Redis in bulk.
+      #redis.pipelined do
+        #error, item = redis.lpop(@key)
+        #(@batch_count-1).times { redis.lpop(@key) }
+      #end.each do |item|
+        #queue_event(item, output_queue) if item
+      #end
+      # --- End commented out implementation of 'batch fetch'
+    rescue ::Redis::CommandError => e
+      if e.to_s =~ /NOSCRIPT/ then
+        @logger.warn("Redis may have been restarted, reloading Redis batch EVAL script", :exception => e);
+        load_batch_script(redis)
+        retry
+      else
+        raise e
+      end
+    end
+  end
+
+  # private
+  def subscribe_stop
+    return if @redis.nil? || !@redis.connected?
+    # if its a SubscribedClient then:
+    # it does not have a disconnect method (yet)
+    if @redis.client.is_a?(::Redis::SubscribedClient)
+      @redis.client.unsubscribe
+    else
+      @redis.client.disconnect
+    end
+    @redis = nil
+  end
+
+  # private
+  def redis_runner
+    begin
+      @redis ||= connect
+      yield
+    rescue ::Redis::BaseError => e
+      @logger.warn("Redis connection problem", :exception => e)
+      # Reset the redis variable to trigger reconnect
+      @redis = nil
+      Stud.stoppable_sleep(1) { stop? }
+      retry if !stop?
+    end
+  end
+
+  # private
+  def channel_runner(output_queue)
+    redis_runner do
+      channel_listener(output_queue)
+    end
+  end
+
+  # private
+  def channel_listener(output_queue)
+    @redis.subscribe(@keys.sample) do |on|
+      on.subscribe do |channel, count|
+        @logger.info("Subscribed", :channel => channel, :count => count)
+      end
+
+      on.message do |channel, message|
+        queue_event(message, output_queue)
+      end
+
+      on.unsubscribe do |channel, count|
+        @logger.info("Unsubscribed", :channel => channel, :count => count)
+      end
+    end
+  end
+
+  def pattern_channel_runner(output_queue)
+    redis_runner do
+      pattern_channel_listener(output_queue)
+    end
+  end
+
+  # private
+  def pattern_channel_listener(output_queue)
+    @redis.psubscribe @keys.sample do |on|
+      on.psubscribe do |channel, count|
+        @logger.info("Subscribed", :channel => channel, :count => count)
+      end
+
+      on.pmessage do |pattern, channel, message|
+        queue_event(message, output_queue)
+      end
+
+      on.punsubscribe do |channel, count|
+        @logger.info("Unsubscribed", :channel => channel, :count => count)
+      end
+    end
+  end
+
+# end
+
+end end end # Redis Inputs  LogStash

data/logstash-input-redis-cluster.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+
+  s.name            = 'logstash-input-redis-cluster'
+  s.version         = '2.0.2'
+  s.licenses        = ['Apache License (2.0)']
+  s.summary         = "This input will read events from a Redis instance"
+  s.description     = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"
+  s.authors         = ["Elastic"]
+  s.email           = 'info@elastic.co'
+  s.homepage        = "http://www.elastic.co/guide/en/logstash/current/index.html"
+  s.require_paths = ["lib"]
+
+  # Files
+  s.files = Dir['lib/**/*','spec/**/*','vendor/**/*','*.gemspec','*.md','CONTRIBUTORS','Gemfile','LICENSE','NOTICE.TXT']
+
+  # Tests
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Special flag to let us know this is actually a logstash plugin
+  s.metadata = { "logstash_plugin" => "true", "logstash_group" => "input" }
+
+  # Gem dependencies
+  s.add_runtime_dependency "logstash-core", ">= 2.0.0.beta2", "< 3.0.0"
+
+  s.add_runtime_dependency 'logstash-codec-json'
+  s.add_runtime_dependency 'redis-rb-cluster'
+
+  s.add_development_dependency 'logstash-devutils'
+end
+

data/spec/inputs/redis_spec.rb

@@ -0,0 +1,247 @@
+require "logstash/devutils/rspec/spec_helper"
+require "redis"
+require "stud/try"
+require 'logstash/inputs/redis_cluster'
+
+def populate(key, event_count)
+  require "logstash/event"
+  redis = Redis.new(:host => "localhost")
+  event_count.times do |value|
+    event = LogStash::Event.new("sequence" => value)
+    Stud.try(10.times) do
+      redis.rpush(key, event.to_json)
+    end
+  end
+end
+
+def process(conf, event_count)
+  events = input(conf) do |pipeline, queue|
+    event_count.times.map{queue.pop}
+  end
+
+  events.each_with_index do |event, i|
+    insist { event["sequence"] } == i
+  end
+end # process
+
+# integration tests ---------------------
+
+describe "inputs/redis_cluster", :redis => true do
+
+  it "should read events from a list" do
+    key = 10.times.collect { rand(10).to_s }.join("")
+    event_count = 1000 + rand(50)
+    # event_count = 100
+    conf = <<-CONFIG
+      input {
+        redis {
+          type => "blah"
+          key => "#{key}"
+          data_type => "list"
+        }
+      }
+    CONFIG
+
+    populate(key, event_count)
+    process(conf, event_count)
+  end
+
+  it "should read events from a list using batch_count" do
+    key = 10.times.collect { rand(10).to_s }.join("")
+    event_count = 1000 + rand(50)
+    conf = <<-CONFIG
+      input {
+        redis {
+          type => "blah"
+          key => "#{key}"
+          data_type => "list"
+          batch_count => #{rand(20)+1}
+        }
+      }
+    CONFIG
+
+    populate(key, event_count)
+    process(conf, event_count)
+  end
+end
+
+# unit tests ---------------------
+
+describe LogStash::Inputs::RedisCluster do
+  let(:redis) { double('redis') }
+  let(:builder) { ->{ redis } }
+  let(:connection) { double('redis_connection') }
+  let(:connected) { [true] }
+  let(:data_type) { 'list' }
+  let(:cfg) { {'key' => 'foo', 'data_type' => data_type} }
+  let(:quit_calls) { [:quit] }
+  let(:accumulator) { [] }
+
+  subject do
+    LogStash::Plugin.lookup("input", "redis_cluster")
+      .new(cfg).add_external_redis_builder(builder)
+  end
+
+  context 'construction' do
+    it 'registers the input' do
+      expect {subject.register}.not_to raise_error
+    end
+  end
+
+  context 'runtime for list data_type' do
+    before do
+      subject.register
+    end
+
+    context 'close when redis is unset' do
+      let(:quit_calls) { [:quit, :unsubscribe, :punsubscribe, :connection, :disconnect!] }
+
+      it 'does not attempt to quit' do
+        allow(redis).to receive(:nil?).and_return(true)
+        quit_calls.each do |call|
+          expect(redis).not_to receive(call)
+        end
+        expect {subject.do_stop}.not_to raise_error
+      end
+    end
+
+    it 'calling the run method, adds events to the queue' do
+      expect(redis).to receive(:blpop).at_least(:once).and_return(['foo', 'l1'])
+
+      allow(redis).to receive(:connected?).and_return(connected.last)
+      allow(redis).to receive(:quit)
+
+      tt = Thread.new do
+        sleep 0.01
+        subject.do_stop
+      end
+
+      subject.run(accumulator)
+
+      tt.join
+
+      expect(accumulator.size).to be > 0
+    end
+
+    it 'multiple close calls, calls to redis once' do
+      subject.use_redis(redis)
+      allow(redis).to receive(:blpop).and_return(['foo', 'l1'])
+      expect(redis).to receive(:connected?).and_return(connected.last)
+      quit_calls.each do |call|
+        expect(redis).to receive(call).at_most(:once)
+      end
+
+      subject.do_stop
+      connected.push(false) #can't use let block here so push to array
+      expect {subject.do_stop}.not_to raise_error
+      subject.do_stop
+    end
+  end
+
+  context 'for the subscribe data_types' do
+    def run_it_thread(inst)
+      Thread.new(inst) do |subj|
+        subj.run(accumulator)
+      end
+    end
+
+    def publish_thread(new_redis, prefix)
+      Thread.new(new_redis, prefix) do |r, p|
+        sleep 0.1
+        2.times do |i|
+          r.publish('foo', "#{p}#{i.next}")
+        end
+      end
+    end
+
+    def close_thread(inst, rt)
+      Thread.new(inst, rt) do |subj, runner|
+        sleep 0.4 # allow the messages through
+        runner.raise(LogStash::ShutdownSignal)
+        subj.close
+      end
+    end
+
+    let(:instance) do
+      inst = described_class.new(cfg)
+      inst.register
+      inst
+    end
+
+    before do
+      subject.register
+      subject.use_redis(redis)
+      allow(connection).to receive(:is_a?).and_return(true)
+      allow(redis).to receive(:client).and_return(connection)
+    end
+
+    before(:example, type: :mocked) do
+      expect(redis).to receive(:connected?).and_return(connected.last)
+      expect(connection).to receive(:unsubscribe)
+
+      quit_calls.each do |call|
+        expect(redis).to receive(call).at_most(:once)
+      end
+    end
+
+    context 'runtime for channel data_type' do
+      let(:data_type) { 'channel' }
+      let(:quit_calls) { [:unsubscribe, :connection] }
+
+      context 'mocked redis' do
+        it 'multiple stop calls, calls to redis once', type: :mocked do
+          subject.do_stop
+          connected.push(false) #can't use let block here so push to array
+          expect {subject.do_stop}.not_to raise_error
+          subject.do_stop
+        end
+      end
+
+      context 'real redis', :redis => true do
+        it 'calling the run method, adds events to the queue' do
+          #simulate the input thread
+          rt = run_it_thread(instance)
+          #simulate the other system thread
+          publish_thread(instance.new_redis_instance, 'c').join
+          #simulate the pipeline thread
+          close_thread(instance, rt).join
+
+          expect(accumulator.size).to eq(2)
+        end
+      end
+    end
+
+    context 'runtime for pattern_channel data_type' do
+      let(:data_type)  { 'pattern_channel' }
+      let(:quit_calls) { [:punsubscribe, :connection] }
+
+      context 'mocked redis' do
+        it 'multiple stop calls, calls to redis once', type: :mocked do
+          subject.do_stop
+          connected.push(false) #can't use let block here so push to array
+          expect {subject.do_stop}.not_to raise_error
+          subject.do_stop
+        end
+      end
+
+      context 'real redis', :redis => true do
+        it 'calling the run method, adds events to the queue' do
+          #simulate the input thread
+          rt = run_it_thread(instance)
+          #simulate the other system thread
+          publish_thread(instance.new_redis_instance, 'pc').join
+          #simulate the pipeline thread
+          close_thread(instance, rt).join
+
+          expect(accumulator.size).to eq(2)
+        end
+      end
+    end
+  end
+
+  describe LogStash::Inputs::Redis do
+    it_behaves_like "an interruptible input plugin" do
+      let(:config) { {'keys' => ['foo'], 'data_type' => 'list'} }
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: logstash-input-redis-cluster
+version: !ruby/object:Gem::Version
+  version: 2.0.2
+platform: ruby
+authors:
+- Elastic
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.beta2
+    - - <
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  name: logstash-core
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.beta2
+    - - <
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: logstash-codec-json
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: redis-rb-cluster
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: logstash-devutils
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program
+email: info@elastic.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTORS
+- Gemfile
+- LICENSE
+- NOTICE.TXT
+- README.md
+- lib/logstash/inputs/redis_cluster.rb
+- logstash-input-redis-cluster.gemspec
+- spec/inputs/redis_spec.rb
+homepage: http://www.elastic.co/guide/en/logstash/current/index.html
+licenses:
+- Apache License (2.0)
+metadata:
+  logstash_plugin: 'true'
+  logstash_group: input
+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.4.5
+signing_key:
+specification_version: 4
+summary: This input will read events from a Redis instance
+test_files:
+- spec/inputs/redis_spec.rb