logstash-devutils 1.3.6-java → 2.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f974a7823953f6c66b9e88fbba39f8b920c41c3226363bc241072e57ce55fab3
-  data.tar.gz: d22e06e09082adb9b93d93aa8c5fafdf88638544625396a832fafa7bb5befc4d
+  metadata.gz: 9529292d4be6bf7ae845758206433d9fff38a8fdf068d4eee49581a595022563
+  data.tar.gz: '09bac2f78a40a15e156f893929a0113bb815234f5e24dacd0b806d94a7db7784'
 SHA512:
-  metadata.gz: 52f7e7169fd63718caf9dcfed7b594784cf639d4fca4534f68eaaef41aff38ad7415cc17b13c8d1bd2e3fe354f0d00996f757d999cdbf1ad217f177bbd87c29b
-  data.tar.gz: 22564997b310028d25d0ad22a9500a3998bf19130c9eafc92c329fd95a87464f60ee5aeab0387ec34a1ffdef50f35e710d8e40f27b5e022831e67fb01669e42d
+  metadata.gz: 2c1f07ee224a06900492e5421031b1f8e4a15705edf0feb91bfe4279853cb30a3bd248933209e20e16d91e19c65f7b8dd6e29b5a75ee293b80c5e3c5032aa4b9
+  data.tar.gz: 1b151df23dd77671425a0874a4b0903de5460d10f93a8b521c8019ff4f71965b8ff52089d2978eebe3dfd0b91e1342dac9ecaffbde6a3fa3735a7a938482b81e

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.0.0
+ - Reinvented helpers using Java pipeline, only LS >= 6.x (JRuby >= 9.1) is supported.
+ - [BREAKING] changes:
+   * `plugin_input` helper no longer works - simply fails with a not implemented error
+   * `type` and `tags` helpers have no effect - they will print a deprecation warning
+   * using gem **insist** is discouraged and has to be pulled in manually 
+     (in *plugin.gemspec* `add_development_dependency 'insist'` and `require "insist"`)
+   * shared examples need to be explicitly required, as they are not re-used that much
+     (in spec_helper.rb `require "logstash/devutils/rspec/shared_examples"'`)
+   * `input` helper now yields a Queue-like collection (with `Queue#pop` blocking semantics)
+     with a default timeout polling mechanism to guard against potential dead-locks 
+
 ## 1.3.6
  - Revert the removal (e.g. add back) of the log4j spec helper. It is still needed for 5.x builds. 
 

data/Gemfile

@@ -1,2 +1,6 @@
 source 'https://rubygems.org'
 gemspec
+
+if Dir.exist?(logstash_path = ENV["LOGSTASH_PATH"])
+  gem 'logstash-core', path: "#{logstash_path}/logstash-core"
+end

data/Rakefile

@@ -0,0 +1,2 @@
+raise "only JRuby is supported" unless defined? JRUBY_VERSION
+require 'bundler/gem_tasks'

data/lib/logstash/devutils/rspec/logstash_helpers.rb

@@ -1,16 +1,37 @@
 require "logstash/agent"
-require "logstash/pipeline"
 require "logstash/event"
+require "logstash/test_pipeline"
+
 require "stud/try"
 require "rspec/expectations"
-require "thread"
+
+require "logstash/environment"
 
 module LogStashHelper
-  class TestPipeline < LogStash::Pipeline
-    public :filter
-    public :flush_filters
+
+  @@excluded_tags = {
+      :integration => true,
+      :redis => true,
+      :socket => true,
+      :performance => true,
+      :couchdb => true,
+      :elasticsearch => true,
+      :elasticsearch_secure => true,
+      :export_cypher => true
+  }
+
+  if LogStash::Environment.windows?
+    @@excluded_tags[:unix] = true
+  else
+    @@excluded_tags[:windows] = true
+  end
+
+  def self.excluded_tags
+    @@excluded_tags
   end
 
+  TestPipeline = LogStash::TestPipeline
+
   DEFAULT_NUMBER_OF_TRY = 5
   DEFAULT_EXCEPTIONS_FOR_TRY = [RSpec::Expectations::ExpectationNotMetError]
 
@@ -23,12 +44,12 @@ module LogStashHelper
   end # def config
 
   def type(default_type)
-    let(:default_type) { default_type }
+    deprecated "type(#{default_type.inspect}) no longer has any effect"
   end
 
   def tags(*tags)
     let(:default_tags) { tags }
-    puts "Setting default tags: #{tags}"
+    deprecated "tags(#{tags.inspect}) - let(:default_tags) are not used"
   end
 
   def sample(sample_event, &block)
@@ -46,18 +67,14 @@ module LogStashHelper
       end
 
       let(:results) do
-        results = []
-        pipeline.instance_eval { @filters.each(&:register) }
+        pipeline.filters.each(&:register)
 
-        event.each do |e|
-          # filter call the block on all filtered events, included new events added by the filter
-          pipeline.filter(e) { |filtered_event| results << filtered_event }
-        end
+        pipeline.run_with(event)
 
         # flush makes sure to empty any buffered events in the filter
         pipeline.flush_filters(:final => true) { |flushed_event| results << flushed_event }
 
-        results.select { |e| !e.cancelled? }
+        pipeline.filter_queue_client.processed_events
       end
 
       # starting at logstash-core 5.3 an initialized pipeline need to be closed
@@ -71,68 +88,97 @@ module LogStashHelper
     end
   end # def sample
 
-  def input(config, &block)
-    pipeline = new_pipeline_from_string(config)
-    queue = Queue.new
-
-    pipeline.instance_eval do
-      # create closure to capture queue
-      @output_func = lambda { |event| queue << event }
-
-      # output_func is now a method, call closure
-      def output_func(event)
-        @output_func.call(event)
-        # We want to return nil or [] since outputs aren't used here
-        # NOTE: In Ruby 1.9.x, Queue#<< returned nil, but in 2.x it returns the queue itself
-        # So we need to be explicit about the return
-        []
-      end
-    end
+  def input(config_string, test_sink: {}, &block); require 'logstash/outputs/test_sink'
+    config_parts = [ config_source(config_string), test_sink_output_source(**test_sink) ]
+
+    # TODO unwrapping output from LogStash::OutputDelegator is cumbersome
+    instances = LogStash::Outputs::TestSink::TRACKER.keys.to_a
+    pipeline = new_pipeline(config_parts)
 
-    pipeline_thread = Thread.new { pipeline.run }
-    sleep 0.1 while !pipeline.ready?
+    start_thread = pipeline.start_and_wait
 
+    queue = (LogStash::Outputs::TestSink::TRACKER.keys.to_a - instances).first.event_store
+
+    # NOTE: we used to pass a Queue here, now its a Java List/Queue collection
     result = block.call(pipeline, queue)
 
     pipeline.shutdown
-    pipeline_thread.join
+    start_thread.join if start_thread.alive?
 
     result
-  end # def input
+  end
 
+  # @deprecated
   def plugin_input(plugin, &block)
-    queue = Queue.new
-
-    input_thread = Thread.new do
-      plugin.run(queue)
-    end
-    result = block.call(queue)
-
-    plugin.do_stop
-    input_thread.join
-    result
+    raise NotImplementedError.new("#{__method__} no longer supported; please refactor")
   end
 
   def agent(&block)
-
     it("agent(#{caller[0].gsub(/ .*/, "")}) runs") do
       pipeline = new_pipeline_from_string(config)
       pipeline.run
       block.call
     end
-  end # def agent
+  end
 
-  def new_pipeline_from_string(string)
-    if TestPipeline.instance_methods.include?(:pipeline_config)
-      settings = ::LogStash::SETTINGS.clone
+  def new_pipeline_from_string(config_string, pipeline_id: :main, test_sink: {})
+    config_parts = [ config_source(config_string) ]
 
-      config_part = org.logstash.common.SourceWithMetadata.new("config_string", "config_string", string)
+    # include a default test_sink output if no outputs given -> we're using it to track processed events
+    # NOTE: a output is required with the JavaPipeline otherwise no processing happen (despite filters being defined)
+    if !OUTPUT_BLOCK_RE.match(config_string)
+      config_parts << test_sink_output_source(**test_sink)
+    elsif test_sink && !test_sink.empty?
+      warn "#{__method__} test_sink: #{test_sink.inspect} options have no effect as config_string has an output"
+    end
 
-      pipeline_config = LogStash::Config::PipelineConfig.new(LogStash::Config::Source::Local, :main, config_part, settings)
-      TestPipeline.new(pipeline_config)
-    else
-      TestPipeline.new(string)
+    if !INPUT_BLOCK_RE.match(config_string)
+      # NOTE: currently using manual batch to push events down the pipe, so an input isn't required
     end
+
+    new_pipeline(config_parts, pipeline_id)
+  end
+
+  def new_pipeline(config_parts, pipeline_id = :main, settings = ::LogStash::SETTINGS.clone)
+    pipeline_config = LogStash::Config::PipelineConfig.new(LogStash::Config::Source::Local, pipeline_id, config_parts, settings)
+    TestPipeline.new(pipeline_config)
+  end
+
+  OUTPUT_BLOCK_RE = defined?(LogStash::Config::Source::Local::ConfigStringLoader::OUTPUT_BLOCK_RE) ?
+                        LogStash::Config::Source::Local::ConfigStringLoader::OUTPUT_BLOCK_RE : /output *{/
+  private_constant :OUTPUT_BLOCK_RE
+
+
+  INPUT_BLOCK_RE = defined?(LogStash::Config::Source::Local::ConfigStringLoader::INPUT_BLOCK_RE) ?
+                        LogStash::Config::Source::Local::ConfigStringLoader::INPUT_BLOCK_RE : /input *{/
+  private_constant :INPUT_BLOCK_RE
+
+  private
+
+  def config_source(config_string)
+    org.logstash.common.SourceWithMetadata.new("string", "config_string", config_string)
   end
+
+  def test_sink_output_source(**config)
+    config = { id: current_spec_id }.merge(config).map { |k, v| "#{k} => #{v.is_a?(String) ? v.inspect : v}" }.join(' ')
+    output_string = "output { test_sink { #{config} } }" # TODO opts for performance store_events: false
+    org.logstash.common.SourceWithMetadata.new("string", "test_sink_output", output_string)
+  end
+
+  def current_spec_id
+    @__current_example_metadata&.[](:location) || 'spec-sample'
+  end
+
+  if RUBY_VERSION > '2.5'
+    def deprecated(msg)
+      Kernel.warn(msg, uplevel: 1)
+    end
+  else # due JRuby 9.1 (Ruby 2.3)
+    def deprecated(msg)
+      loc = caller_locations[1]
+      Kernel.warn("#{loc.path}:#{loc.lineno}: warning: #{msg}")
+    end
+  end
+
 end # module LogStash
 

data/lib/logstash/devutils/rspec/spec_helper.rb

@@ -14,10 +14,7 @@ end
 
 require "logstash-core"
 require "logstash/logging"
-require "logstash/environment"
 require "logstash/devutils/rspec/logstash_helpers"
-require "logstash/devutils/rspec/shared_examples"
-require "insist"
 
 Thread.abort_on_exception = true
 
@@ -28,35 +25,32 @@ unless java.lang.System.getProperty("log4j.configurationFile")
 end
 
 $TESTING = true
-if RUBY_VERSION < "1.9.2"
-  $stderr.puts "Ruby 1.9.2 or later is required. (You are running: " + RUBY_VERSION + ")"
-  raise LoadError
+if RUBY_VERSION < "2.3"
+  raise LoadError.new("Ruby >= 2.3.0 or later is required. (You are running: " + RUBY_VERSION + ")")
 end
 
-if ENV["TEST_DEBUG"]
-  LogStash::Logging::Logger::configure_logging("WARN")
+if level = (ENV["TEST_DEBUG"] || ENV['LOGGER_LEVEL'])
+  logger, level = level.split('=') # 'logstash.filters.grok=DEBUG'
+  level, logger = logger, nil if level.nil? # only level given e.g. 'DEBUG'
+  level = org.apache.logging.log4j.Level.toLevel(level, org.apache.logging.log4j.Level::WARN)
+  LogStash::Logging::Logger::configure_logging(level.to_s, logger)
 else
-  LogStash::Logging::Logger::configure_logging("OFF")
+  LogStash::Logging::Logger::configure_logging('ERROR')
 end
 
-# removed the strictness check, it did not seem to catch anything
-
 RSpec.configure do |config|
   # for now both include and extend are required because the newly refactored "input" helper method need to be visible in a "it" block
   # and this is only possible by calling include on LogStashHelper
   config.include LogStashHelper
   config.extend LogStashHelper
 
-  exclude_tags = { :redis => true, :socket => true, :performance => true, :couchdb => true, :elasticsearch => true, :elasticsearch_secure => true, :export_cypher => true, :integration => true }
+  config.filter_run_excluding LogStashHelper.excluded_tags
 
-  if LogStash::Environment.windows?
-    exclude_tags[:unix] = true
-  else
-    exclude_tags[:windows] = true
+  config.around(:each) do |example|
+    @__current_example_metadata = example.metadata
+    example.run
   end
 
-  config.filter_run_excluding exclude_tags
-
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.

data/lib/logstash/outputs/test_sink.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+require "logstash/namespace"
+require "logstash/outputs/base"
+require "logstash/errors"
+
+# This output simply discards (but tracks) received events.
+class LogStash::Outputs::TestSink < LogStash::Outputs::Base
+
+  concurrency :shared
+
+  config_name "test_sink"
+
+  # Whether we're tracking events received or simply act as a true sink.
+  config :store_events, :validate => :boolean, :default => true
+  # Plugin could not release itself (on close) if needed to keep its events around.
+  config :release_on_close, :validate => :boolean, :default => true
+  # Even poll timeout in milliseconds (for input plugin tests consuming events).
+  # HINT: set to 0 (null) to wait forever.
+  config :event_poll_timeout, :default => 5 * 1000
+
+  TRACKER = java.util.WeakHashMap.new
+
+  # @override plugin hook
+  def register
+    TRACKER[self] = Queue.new(@event_poll_timeout.to_f * 1000)
+  end
+
+  # @override plugin impl
+  def receive(event)
+    event_store << event if store_events?
+  end
+
+  # @override plugin hook
+  def close
+    TRACKER.delete(self) if release_on_close?
+  end
+
+  def store_events?
+    !!@store_events
+  end
+
+  def release_on_close?
+    !!@release_on_close
+  end
+
+  # Clears the event store.
+  def clear!
+    event_store.clear
+  end
+
+  # @return [Queue] (enumerable) event store
+  def event_store
+    TRACKER[self] || raise("#{self} not registered; please call plugin.register before use")
+  end
+
+  # TODO refactor to java.util.concurrent.ConcurrentLinkedQueue
+  # Interestingly, using a ConcurrentLinkedQueue gets specs that depend on pop-ing events
+  # from the output (e.g. syslog input plugin) passing fine with the old Ruby pipeline.
+  # The Java pipeline seems to reach a shutdown before the input yielded events are to be consumed.
+
+  class Queue < java.util.concurrent.LinkedBlockingQueue
+
+    java_import java.util.concurrent.TimeoutException
+
+    MILLISECONDS = java.util.concurrent.TimeUnit::MILLISECONDS
+    private_constant :MILLISECONDS
+
+    def initialize(poll_timeout = nil)
+      super()
+      @timeout = poll_timeout.to_i
+    end
+
+    # Ruby Queue like pop-er with (default) blocking.
+    # @see Queue#pop
+    def pop(non_block = nil)
+      # for compatibility we're making it behave like Ruby's Queue
+      return poll if non_block
+      @timeout.zero? ? take :
+          (poll(@timeout, MILLISECONDS) || timeout!(__method__))
+    end
+    alias deq pop
+    alias shift pop
+
+    private
+
+    def timeout!(op)
+      raise TimeoutException.new("#{op.inspect} did not complete (in #{@timeout}ms)")
+    end
+  end
+end

data/lib/logstash/test_pipeline.rb

@@ -0,0 +1,166 @@
+require "logstash/pipeline"
+require "logstash/java_pipeline"
+
+module LogStash
+  class TestPipeline < LogStash::JavaPipeline
+    public :flush_filters
+
+    def run_with(events)
+      if inputs&.any? # will work but might be unintended
+        config = "\n #{config_str}" if $VERBOSE
+        warn "#{self} pipeline is getting events pushed manually while having inputs: #{inputs.inspect}  #{config}"
+      end
+      # TODO could we handle a generator (Enumerator) ?
+      queue.write_client.push_batch events.to_a
+      queue_read_client = filter_queue_client
+      # potentially handle run_with called multiple times (re-use the same instance) :
+      if queue_read_client.is_a?(EventTrackingQueueReadClientDelegator)
+        queue_read_client.reset_events!
+      else
+        # start_worker using @filter_queue_client on 6.3, since 6.4 a reader method is used
+        # to make things compatible with 6.3 we're assigning the @filter_queue_client ivar
+        @filter_queue_client = EventTrackingQueueReadClientDelegator.new queue_read_client
+      end
+      run
+    end
+
+    # @override for WorkerLoop to pick it up
+    # @note only works since LS 6.4 (need to use tha actual ivar for 6.3)
+    def filter_queue_client
+      @filter_queue_client || super
+    end
+
+    java_import org.apache.logging.log4j.ThreadContext unless const_defined?(:ThreadContext)
+
+    def start_and_wait
+      parent_thread = Thread.current
+      @finished_execution.make_false
+      @finished_run&.make_false # only since 6.5
+
+      @thread = Thread.new do
+        begin
+          LogStash::Util.set_thread_name("pipeline.#{pipeline_id}")
+          ThreadContext.put("pipeline.id", pipeline_id)
+          run
+          @finished_run&.make_true
+        rescue => e
+          close
+          parent_thread.raise(e)
+        ensure
+          @finished_execution.make_true
+        end
+      end
+
+      unless wait_until_started
+        raise "failed to start pipeline: #{self}\n with config: #{config_str.inspect}"
+      end
+
+      @thread
+    end
+
+    class EventTrackingQueueReadClientDelegator
+      include org.logstash.execution.QueueReadClient
+      java_import org.logstash.execution.QueueReadClient
+
+      attr_reader :processed_events
+
+      def initialize(delegate)
+        # NOTE: can not use LogStash::MemoryReadClient#read_batch due its JavaObject wrapping
+        @delegate = delegate.to_java(QueueReadClient)
+        @processed_events = []
+      end
+
+      # @override QueueBatch readBatch() throws InterruptedException;
+      def readBatch
+        QueueBatchDelegator.new(self, @delegate.read_batch)
+      end
+
+      # @override void closeBatch(QueueBatch batch) throws IOException;
+      def closeBatch(batch)
+        @delegate.close_batch(batch)
+      end
+
+      # @override boolean isEmpty();
+      def isEmpty
+        @delegate.empty?
+      end
+
+      # @override QueueBatch newBatch();
+      def newBatch
+        @delegate.new_batch
+      end
+
+      # @override void startMetrics(QueueBatch batch);
+      def startMetrics(batch)
+        @delegate.start_metrics(batch)
+      end
+
+      # @override void addOutputMetrics(int filteredSize);
+      def addOutputMetrics(filteredSize)
+        @delegate.add_output_metrics(filteredSize)
+      end
+
+      # @override void addFilteredMetrics(int filteredSize);
+      def addFilteredMetrics(filteredSize)
+        @delegate.add_filtered_metrics(filteredSize)
+      end
+
+      # @override
+      def set_batch_dimensions(batch_size, batch_delay)
+        @delegate.set_batch_dimensions(batch_size, batch_delay)
+      end
+
+      # @override
+      def close
+        @delegate.close
+      end
+
+      # @override dispatch to delegate
+      def method_missing(method, *args)
+        @delegate.public_send(method, *args)
+      end
+
+      def filtered_events(events)
+        @processed_events.concat(events)
+      end
+
+      def reset_events!
+        @processed_events = []
+      end
+
+    end
+
+    class QueueBatchDelegator
+      include org.logstash.execution.QueueBatch
+
+      def initialize(event_tracker, delegate)
+        @event_tracker = event_tracker
+        @delegate = delegate
+      end
+
+      # @override RubyArray to_a();
+      def to_a
+        @delegate.to_a.tap do |events|
+          # filters out rogue (cancelled) events
+          @event_tracker.filtered_events events
+        end
+      end
+
+      # @override int filteredSize();
+      def filteredSize
+        @delegate.to_java.filtered_size
+      end
+
+      # @override void merge(IRubyObject event);
+      def merge(event)
+        @delegate.merge(event)
+      end
+
+      # @override void close() throws IOException;
+      def close
+        @delegate.close
+      end
+
+    end
+  end
+end

data/logstash-devutils.gemspec

@@ -1,28 +1,30 @@
-if RUBY_PLATFORM != "java"
-  raise "Only JRuby is supported"
-end
+raise "Only JRuby is supported" if RUBY_PLATFORM != "java"
 
 Gem::Specification.new do |spec|
   files = %x{git ls-files}.split("\n")
 
   spec.name = "logstash-devutils"
-  spec.version = "1.3.6"
-  spec.licenses = ["Apache License (2.0)"]
-  spec.summary = "logstash-devutils"
-  spec.description = "logstash-devutils"
+  spec.version = "2.0.0"
+  spec.license = "Apache-2.0"
   spec.authors = ["Elastic"]
   spec.email = "info@elastic.co"
   spec.homepage = "http://www.elastic.co/guide/en/logstash/current/index.html"
 
+  spec.summary = %q{An assortment of tooling/libraries to make Logstash plugin development and releasing a bit easier.}
+  spec.description = %q{logstash-devutils gem is meant to be used as a development dependency from other plugins/gems.}
+
   spec.files = files
   spec.require_paths << "lib"
 
   spec.platform = "java"
 
-  # Please note that devutils is meant to be used as a developement dependency from other
-  # plugins/gems. As such, devutils OWN development dependencies (any add_development_dependency)
-  # will be ignored when bundling a plugin/gem which uses/depends on devutils. This is
-  # why all devutils own dependencies should normally be specified as add_runtime_dependency.
+  spec.required_ruby_version = '>= 2.3'
+
+  # Please note that devutils is meant to be used as a development dependency from other plugins/gems.
+  # As such, devutils' OWN development dependencies (any add_development_dependency) will be ignored when
+  # bundling a plugin/gem which uses/depends on devutils.
+  #
+  # This is why all devutils own dependencies should normally be specified as add_runtime_dependency.
 
   # It is important to specify rspec "~> 3.0" and not "~> 3.0.0" (or any other version to the patch level)
   # otherwise the version constrain will have to be met up to the minor release version and only allow
@@ -35,12 +37,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rake" # MIT License
   spec.add_runtime_dependency "gem_publisher" # MIT License
   spec.add_runtime_dependency "minitar" # GPL2|Ruby License
-  spec.add_runtime_dependency "logstash-core-plugin-api", "<= 2.99", ">= 2.0"
 
-  # Should be removed as soon as the plugins are using insist by their
-  # own, and not relying on being required by the spec helper.
-  # (some plugins does it, some use insist throw spec_helper)
-  spec.add_runtime_dependency "insist", "1.0.0" # (Apache 2.0 license)
+  spec.add_runtime_dependency "logstash-core", ">= 6.3"
+
+  # Some plugins are (still) using insist by their own, but we no longer force this dependency on others.
+  #spec.add_runtime_dependency "insist" # (Apache 2.0 license)
   spec.add_runtime_dependency "kramdown", '1.14.0'
   spec.add_runtime_dependency "stud", " >= 0.0.20"
   spec.add_runtime_dependency "fivemat"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-devutils
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 2.0.0
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-11-03 00:00:00.000000000 Z
+date: 2020-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -83,37 +83,17 @@ dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '2.99'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
-  name: logstash-core-plugin-api
+        version: '6.3'
+  name: logstash-core
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '2.99'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  name: insist
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '6.3'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -156,7 +136,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: logstash-devutils
+description: logstash-devutils gem is meant to be used as a development dependency
+  from other plugins/gems.
 email: info@elastic.co
 executables: []
 extensions: []
@@ -165,6 +146,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - LICENSE
+- Rakefile
 - lib/logstash/devutils/rake.rb
 - lib/logstash/devutils/rake/publish.rake
 - lib/logstash/devutils/rake/vendor.rake
@@ -172,10 +154,12 @@ files:
 - lib/logstash/devutils/rspec/logstash_helpers.rb
 - lib/logstash/devutils/rspec/shared_examples.rb
 - lib/logstash/devutils/rspec/spec_helper.rb
+- lib/logstash/outputs/test_sink.rb
+- lib/logstash/test_pipeline.rb
 - logstash-devutils.gemspec
 homepage: http://www.elastic.co/guide/en/logstash/current/index.html
 licenses:
-- Apache License (2.0)
+- Apache-2.0
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -186,7 +170,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -197,5 +181,6 @@ rubyforge_project:
 rubygems_version: 2.6.13
 signing_key:
 specification_version: 4
-summary: logstash-devutils
+summary: An assortment of tooling/libraries to make Logstash plugin development and
+  releasing a bit easier.
 test_files: []