logstash-core 1.5.0.snapshot1-java → 1.5.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 743d8972e12c8d8eea45b4835d3aa61fd3552670
-  data.tar.gz: 072a5f662af302799cbb330fb4a61aac962c3355
+  metadata.gz: fafba05d878e14fa01c8fc5a8b25ab4417fdecb3
+  data.tar.gz: 40ecd05d0b96587607bdb8d3f8d4ac8c51e921d1
 SHA512:
-  metadata.gz: 9b491439a41e88c027ecf0c3639d8183b894e38561802b0c1aa40a2c2a6080e6a25fc1203b8878af4dd7ef81ab0c771a43becb040519672f14feb5edd758923d
-  data.tar.gz: 525d34020708de68d2623eecfed261448864ad0f0818553e5b5d9b2c1c99274ce7f441a96446d99517d80932eb7c88f688afcb53c1b0ff92cd6e3c31098e5f65
+  metadata.gz: a96dcfa7d2f103ef370095269e3e6091411cd55634ad665517232097fd0907bf10a6313648823d5d682beaeecbcc4b9e20eb4c78c9f5dcd578698d75dcf3ae0f
+  data.tar.gz: 1a7485abfbd935277984f66a8bead8425b7ed7d389845751325eff72922755ea1eb8fcad1a09e9d2fc7e67fb5211a0ea01083be7f60df6b67ed975a69a3a8cb6

data/lib/logstash/agent.rb

@@ -113,8 +113,16 @@ class LogStash::Agent < Clamp::Command
 
     # Make SIGINT shutdown the pipeline.
     sigint_id = Stud::trap("INT") do
-      @logger.warn(I18n.t("logstash.agent.sigint"))
-      pipeline.shutdown
+
+      if @interrupted_once
+        @logger.fatal(I18n.t("logstash.agent.forced_sigint"))
+        exit
+      else
+        @logger.warn(I18n.t("logstash.agent.sigint"))
+        Thread.new(@logger) {|logger| sleep 5; logger.warn(I18n.t("logstash.agent.slow_shutdown")) }
+        @interrupted_once = true
+        pipeline.shutdown
+      end
     end
 
     # Make SIGTERM shutdown the pipeline.

data/lib/logstash/config/config_ast.rb

@@ -76,7 +76,11 @@ module LogStash; module Config; module AST
     @defered_conditionals_index = val
   end
 
-  class Node < Treetop::Runtime::SyntaxNode; end
+  class Node < Treetop::Runtime::SyntaxNode
+    def text_value_for_comments
+      text_value.gsub(/[\r\n]/, " ")
+    end
+  end
 
   class Config < Node
     def compile
@@ -412,14 +416,14 @@ module LogStash; module Config; module AST
   class If < BranchEntry
     def compile
       children = recursive_inject { |e| e.is_a?(Branch) || e.is_a?(Plugin) }
-      return "if #{condition.compile} # if #{condition.text_value}\n" \
+      return "if #{condition.compile} # if #{condition.text_value_for_comments}\n" \
         << children.collect(&:compile).map { |s| s.split("\n", -1).map { |l| "  " + l }.join("\n") }.join("") << "\n"
     end
   end
   class Elsif < BranchEntry
     def compile
       children = recursive_inject { |e| e.is_a?(Branch) || e.is_a?(Plugin) }
-      return "elsif #{condition.compile} # else if #{condition.text_value}\n" \
+      return "elsif #{condition.compile} # else if #{condition.text_value_for_comments}\n" \
         << children.collect(&:compile).map { |s| s.split("\n", -1).map { |l| "  " + l }.join("\n") }.join("") << "\n"
     end
   end

data/lib/logstash/inputs/base.rb

@@ -40,7 +40,7 @@ class LogStash::Inputs::Base < LogStash::Plugin
   # or in another character set other than `UTF-8`.
   #
   # This only affects `plain` format logs since json is `UTF-8` already.
-  config :charset, :validate => ::Encoding.name_list, :deprecated => true
+  config :charset, :deprecated => "Use the codec setting instead. For example: input { %PLUGIN% { codec => plain { charset => \"UTF-8\" } }"
 
   # If format is `json`, an event `sprintf` string to build what
   # the display `@message` should be given (defaults to the raw JSON).
@@ -101,7 +101,7 @@ class LogStash::Inputs::Base < LogStash::Plugin
 
   protected
   def to_event(raw, source)
-    raise LogStash::ThisMethodWasRemoved("LogStash::Inputs::Base#to_event - you should use codecs now instead of to_event. Not sure what this means? Get help on logstash-users@googlegroups.com!")
+    raise LogStash::ThisMethodWasRemoved("LogStash::Inputs::Base#to_event - you should use codecs now instead of to_event. Not sure what this means? Get help on https://discuss.elastic.co/c/logstash")
   end # def to_event
 
   protected

data/lib/logstash/patches/bugfix_jruby_2558.rb

@@ -3,8 +3,8 @@ require "logstash/environment"
 if LogStash::Environment.windows? && LogStash::Environment.jruby?
   require "socket"
   module JRubyBug2558SocketPeerAddrBugFix
-    def peeraddr
-      orig_peeraddr.map do |v|
+    def peeraddr(*args)
+      orig_peeraddr(*args).map do |v|
         case v
         when String
           v.force_encoding(Encoding::UTF_8)

data/lib/logstash/patches/bundler.rb

@@ -9,6 +9,21 @@ module ::Bundler
     end
   end
 
+  # Patch to prevent Bundler to save a .bundle/config file in the root 
+  # of the application
+  class Settings
+    def set_key(key, value, hash, file)
+      key = key_for(key)
+
+      unless hash[key] == value
+        hash[key] = value
+        hash.delete(key) if value.nil?
+      end
+
+      value
+    end
+  end
+
   # Add the Bundler.reset! method which has been added in master but is not in 1.7.9.
   class << self
     unless self.method_defined?("reset!")

data/lib/logstash/pipeline.rb

@@ -115,7 +115,7 @@ class LogStash::Pipeline
   end
 
   def shutdown_filters
-    @flusher_lock.synchronize { @flusher_thread.kill }
+    @flusher_thread.kill
     @input_to_filter.push(LogStash::SHUTDOWN)
   end
 
@@ -156,8 +156,7 @@ class LogStash::Pipeline
       Thread.new { filterworker }
     end
 
-    @flusher_lock = Mutex.new
-    @flusher_thread = Thread.new { Stud.interval(5) { @flusher_lock.synchronize { @input_to_filter.push(LogStash::FLUSH) } } }
+    @flusher_thread = Thread.new { Stud.interval(5) { @input_to_filter.push(LogStash::FLUSH) } }
   end
 
   def start_outputs
@@ -220,7 +219,7 @@ class LogStash::Pipeline
         when LogStash::FlushEvent
           # handle filter flushing here so that non threadsafe filters (thus only running one filterworker)
           # don't have to deal with thread safety implementing the flush method
-          @flusher_lock.synchronize { flush_filters_to_output! }
+          flush_filters_to_output!
         when LogStash::ShutdownEvent
           # pass it down to any other filterworker and stop this worker
           @input_to_filter.push(event)

data/lib/logstash/util/accessors.rb

@@ -2,90 +2,120 @@
 
 require "logstash/namespace"
 require "logstash/util"
+require "thread_safe"
 
 module LogStash::Util
 
-  # PathCache is a singleton which globally caches a parsed fields path for the path to the
-  # container hash and key in that hash.
+  # PathCache is a singleton which globally caches the relation between a field reference and its
+  # decomposition into a [key, path array] tuple. For example the field reference [foo][bar][baz]
+  # is decomposed into ["baz", ["foo", "bar"]].
   module PathCache
     extend self
 
-    def get(accessor)
-      @cache ||= {}
-      @cache[accessor] ||= parse(accessor)
+    # requiring libraries and defining constants is thread safe in JRuby so
+    # PathCache::CACHE will be corretly initialized, once, when accessors.rb
+    # will be first required
+    CACHE = ThreadSafe::Cache.new
+
+    def get(field_reference)
+      # the "get_or_default(x, nil) || put(x, parse(x))" is ~2x faster than "get || put" because the get call is
+      # proxied through the JRuby JavaProxy op_aref method. the correct idiom here would be to use
+      # "compute_if_absent(x){parse(x)}" but because of the closure creation, it is ~1.5x slower than
+      # "get_or_default || put".
+      # this "get_or_default || put" is obviously non-atomic which is not really important here
+      # since all threads will set the same value and this cache will stabilize very quickly after the first
+      # few events.
+      CACHE.get_or_default(field_reference, nil) || CACHE.put(field_reference, parse(field_reference))
     end
 
-    def parse(accessor)
-      path = accessor.split(/[\[\]]/).select{|s| !s.empty?}
+    def parse(field_reference)
+      path = field_reference.split(/[\[\]]/).select{|s| !s.empty?}
       [path.pop, path]
     end
   end
 
-  # Accessors uses a lookup table to speedup access of an accessor field of the type
+  # Accessors uses a lookup table to speedup access of a field reference of the form
   # "[hello][world]" to the underlying store hash into {"hello" => {"world" => "foo"}}
   class Accessors
 
+    # @param store [Hash] the backing data store field refereces point to
     def initialize(store)
       @store = store
+
+      # @lut is a lookup table between a field reference and a [target, key] tuple
+      # where target is the containing Hash or Array for key in @store.
+      # this allows us to directly access the containing object for key instead of
+      # walking the field reference path into the inner @store objects
       @lut = {}
     end
 
-    def get(accessor)
-      target, key = lookup(accessor)
-      unless target.nil?
-        target.is_a?(Array) ? target[key.to_i] : target[key]
-      end
+    # @param field_reference [String] the field reference
+    # @return [Object] the value in @store for this field reference
+    def get(field_reference)
+      target, key = lookup(field_reference)
+      return nil unless target
+      target.is_a?(Array) ? target[key.to_i] : target[key]
     end
 
-    def set(accessor, value)
-      target, key = store_and_lookup(accessor)
+    # @param field_reference [String] the field reference
+    # @param value [Object] the value to set in @store for this field reference
+    # @return [Object] the value set
+    def set(field_reference, value)
+      target, key = lookup_or_create(field_reference)
       target[target.is_a?(Array) ? key.to_i : key] = value
     end
 
-    def strict_set(accessor, value)
-      set(accessor, LogStash::Event.validate_value(value))
-    end
-
-    def del(accessor)
-      target, key = lookup(accessor)
-      unless target.nil?
-        target.is_a?(Array) ? target.delete_at(key.to_i) : target.delete(key)
-      end
+    # @param field_reference [String] the field reference to remove
+    # @return [Object] the removed value in @store for this field reference
+    def del(field_reference)
+      target, key = lookup(field_reference)
+      return nil unless target
+      target.is_a?(Array) ? target.delete_at(key.to_i) : target.delete(key)
     end
 
-    def include?(accessor)
-      target, key = lookup_path(accessor)
+    # @param field_reference [String] the field reference to test for inclusion in the store
+    # @return [Boolean] true if the store contains a value for this field reference
+    def include?(field_reference)
+      target, key = lookup(field_reference)
       return false unless target
+
       target.is_a?(Array) ? !target[key.to_i].nil? : target.include?(key)
     end
 
     private
 
-    def lookup(accessor)
-      target, key = lookup_path(accessor)
-      if target.nil?
-        [target, key]
-      else
-        @lut[accessor] = [target, key]
-      end
+    # retrieve the [target, key] tuple associated with this field reference
+    # @param field_reference [String] the field referece
+    # @return [[Object, String]] the  [target, key] tuple associated with this field reference
+    def lookup(field_reference)
+      @lut[field_reference] ||= find_target(field_reference)
     end
 
-    def store_and_lookup(accessor)
-      @lut[accessor] ||= store_path(accessor)
+    # retrieve the [target, key] tuple associated with this field reference and create inner
+    # container objects if they do not exists
+    # @param field_reference [String] the field referece
+    # @return [[Object, String]] the  [target, key] tuple associated with this field reference
+    def lookup_or_create(field_reference)
+      @lut[field_reference] ||= find_or_create_target(field_reference)
     end
 
-    def lookup_path(accessor)
-      key, path = PathCache.get(accessor)
+    # find the target container object in store for this field reference
+    # @param field_reference [String] the field referece
+    # @return [Object] the target container object in store associated with this field reference
+    def find_target(field_reference)
+      key, path = PathCache.get(field_reference)
       target = path.inject(@store) do |r, k|
-        if r.nil?
-          return nil
-        end
+        return nil unless r
         r[r.is_a?(Array) ? k.to_i : k]
       end
-      [target, key]
+      target ? [target, key] : nil
     end
 
-    def store_path(accessor)
+    # find the target container object in store for this field reference and create inner
+    # container objects if they do not exists
+    # @param field_reference [String] the field referece
+    # @return [Object] the target container object in store associated with this field reference
+    def find_or_create_target(accessor)
       key, path = PathCache.get(accessor)
       target = path.inject(@store) {|r, k| r[r.is_a?(Array) ? k.to_i : k] ||= {}}
       [target, key]

data/lib/logstash/version.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # The version of logstash.
-LOGSTASH_VERSION = "1.5.0.snapshot1"
+LOGSTASH_VERSION = "1.5.1"
 
 # Note to authors: this should not include dashes because 'gem' barfs if
 # you include a dash in the version string.

data/locales/en.yml

@@ -66,6 +66,12 @@ en:
         SIGINT received. Shutting down the pipeline.
       sigterm: >-
         SIGTERM received. Shutting down the pipeline.
+      slow_shutdown: |-
+        Received shutdown signal, but pipeline is still waiting for in-flight events
+        to be processed. Sending another ^C will force quit Logstash, but this may cause
+        data loss.
+      forced_sigint: >-
+        SIGINT received. Terminating immediately..
       configtest-flag-information: |-
         You may be interested in the '--configtest' flag which you can
         use to validate logstash's configuration before you choose

data/logstash-core.gemspec

@@ -33,6 +33,8 @@ Gem::Specification.new do |gem|
   # filetools and rakelib
   gem.add_runtime_dependency "minitar", "~> 0.5.4"
 
+  gem.add_runtime_dependency "thread_safe", "~> 0.3.5" #(Apache 2.0 license)
+
   if RUBY_PLATFORM == 'java'
     gem.platform = RUBY_PLATFORM
     gem.add_runtime_dependency "jrjackson", "~> 0.2.8" #(Apache 2.0 license)

data/spec/core/conditionals_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module ConditionalFanciness
   def description
-    return example.metadata[:example_group][:description_args][0]
+    return self.metadata[:description]
   end
 
   def conditional(expression, &block)

data/spec/core/config_spec.rb

@@ -48,6 +48,44 @@ describe LogStashConfigParser do
   end
 
   context "#compile" do
+    context "if with multiline conditionals" do
+      let(:config) { <<-CONFIG }
+        filter {
+          if [something]
+             or [anotherthing]
+             or [onemorething] {
+          }
+        }
+      CONFIG
+      subject { LogStashConfigParser.new }
+         
+      it "should compile successfully" do
+        result = subject.parse(config)
+        expect(result).not_to(be_nil)
+        expect { eval(result.compile) }.not_to(raise_error)
+      end
+    end
+
+    context "elsif with multiline conditionals" do
+      let(:config) { <<-CONFIG }
+        filter {
+          if [notathing] {
+          } else if [something]
+                or [anotherthing]
+                or [onemorething] {
+          }
+        }
+      CONFIG
+      subject { LogStashConfigParser.new }
+         
+      it "should compile successfully" do
+        result = subject.parse(config)
+        expect(result).not_to(be_nil)
+        expect { eval(result.compile) }.not_to(raise_error)
+      end
+    end
+
+
     context "invalid configuration" do
       it "rejects duplicate hash key" do
         parser = LogStashConfigParser.new

data/spec/core/event_spec.rb

@@ -123,32 +123,32 @@ describe LogStash::Event do
 
     context "#include?" do
       it "should include existing fields" do
-        expect(subject.include?("c")).to be_true
-        expect(subject.include?("[c][d]")).to be_true
-        expect(subject.include?("[j][k4][0][nested]")).to be_true
+        expect(subject.include?("c")).to eq(true)
+        expect(subject.include?("[c][d]")).to eq(true)
+        expect(subject.include?("[j][k4][0][nested]")).to eq(true)
       end
 
       it "should include field with nil value" do
-        expect(subject.include?("nilfield")).to be_true
+        expect(subject.include?("nilfield")).to eq(true)
       end
 
       it "should include @metadata field" do
-        expect(subject.include?("@metadata")).to be_true
+        expect(subject.include?("@metadata")).to eq(true)
       end
 
       it "should include field within @metadata" do
-        expect(subject.include?("[@metadata][fancy]")).to be_true
+        expect(subject.include?("[@metadata][fancy]")).to eq(true)
       end
 
       it "should not include non-existing fields" do
-        expect(subject.include?("doesnotexist")).to be_false
-        expect(subject.include?("[j][doesnotexist]")).to be_false
-        expect(subject.include?("[tag][0][hello][yes]")).to be_false
+        expect(subject.include?("doesnotexist")).to eq(false)
+        expect(subject.include?("[j][doesnotexist]")).to eq(false)
+        expect(subject.include?("[tag][0][hello][yes]")).to eq(false)
       end
 
       it "should include within arrays" do
-        expect(subject.include?("[tags][0]")).to be_true
-        expect(subject.include?("[tags][1]")).to be_false
+        expect(subject.include?("[tags][0]")).to eq(true)
+        expect(subject.include?("[tags][1]")).to eq(false)
       end
     end
 

data/spec/core/pipeline_spec.rb

@@ -58,16 +58,13 @@ end
 
 describe LogStash::Pipeline do
 
-  context "teardown" do
-
-    before(:each) do
-      LogStash::Plugin.stub(:lookup)
-        .with("input", "dummyinput").and_return(DummyInput)
-      LogStash::Plugin.stub(:lookup)
-        .with("codec", "plain").and_return(DummyCodec)
-      LogStash::Plugin.stub(:lookup)
-        .with("output", "dummyoutput").and_return(DummyOutput)
-    end
+context "teardown" do
+
+  before(:each) do
+    allow(LogStash::Plugin).to receive(:lookup).with("input", "dummyinput").and_return(DummyInput)
+    allow(LogStash::Plugin).to receive(:lookup).with("codec", "plain").and_return(DummyCodec)
+    allow(LogStash::Plugin).to receive(:lookup).with("output", "dummyoutput").and_return(DummyOutput)
+  end
 
     let(:test_config_without_output_workers) {
       <<-eos

data/spec/lib/logstash/bundler_spec.rb

@@ -30,6 +30,7 @@ describe LogStash::Bundler do
     original_stderr = $stderr
 
     subject { LogStash::Bundler.invoke!(options) }
+
     # by default we want to fail fast on the test
     let(:options) { { :install => true, :max_tries => 0, :without => [:development]} }
     let(:bundler_args) { LogStash::Bundler.bundler_arguments(options) }

data/spec/lib/logstash/java_integration_spec.rb

@@ -13,7 +13,7 @@ describe "Java integration" do
     context "Java::JavaUtil::ArrayList" do
 
       it "should report to be a Ruby Array" do
-        expect(Java::JavaUtil::ArrayList.new.is_a?(Array)).to be_true
+        expect(Java::JavaUtil::ArrayList.new.is_a?(Array)).to eq(true)
       end
 
       it "should be class equivalent to Ruby Array" do
@@ -26,13 +26,13 @@ describe "Java integration" do
           end
         end.not_to raise_error
 
-        expect(Array === Java::JavaUtil::ArrayList.new).to be_true
+        expect(Array === Java::JavaUtil::ArrayList.new).to eq(true)
       end
     end
 
     context "Java::JavaUtil::LinkedHashMap" do
       it "should report to be a Ruby Hash" do
-        expect(Java::JavaUtil::LinkedHashMap.new.is_a?(Hash)).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new.is_a?(Hash)).to eq(true)
       end
 
       it "should be class equivalent to Ruby Hash" do
@@ -45,7 +45,7 @@ describe "Java integration" do
           end
         end.not_to raise_error
 
-        expect(Hash === Java::JavaUtil::LinkedHashMap.new).to be_true
+        expect(Hash === Java::JavaUtil::LinkedHashMap.new).to eq(true)
       end
     end
   end
@@ -200,57 +200,57 @@ describe "Java integration" do
     context "Java Map interface should report key with nil value as included" do
 
       it "should support include? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).include?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).include?("foo")).to eq(true)
       end
 
       it "should support has_key? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).has_key?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).has_key?("foo")).to eq(true)
       end
 
       it "should support member? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).member?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).member?("foo")).to eq(true)
       end
 
       it "should support key? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).key?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).key?("foo")).to eq(true)
       end
     end
 
     context "Java Map interface should report key with a value as included" do
 
       it "should support include? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).include?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).include?("foo")).to eq(true)
       end
 
       it "should support has_key? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("foo")).to eq(true)
       end
 
       it "should support member? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("foo")).to eq(true)
       end
 
       it "should support key? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("foo")).to be_true
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("foo")).to eq(true)
       end
     end
 
     context "Java Map interface should report non existing key as not included" do
 
       it "should support include? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).include?("bar")).to be_false
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1})).not_to include("bar")
       end
 
       it "should support has_key? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("bar")).to be_false
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("bar")).to eq(false)
       end
 
       it "should support member? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("bar")).to be_false
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("bar")).to eq(false)
       end
 
       it "should support key? method" do
-        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("bar")).to be_false
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("bar")).to eq(false)
       end
     end
   end

data/spec/util/accessors_spec.rb

@@ -121,14 +121,6 @@ describe LogStash::Util::Accessors, :if => true do
       expect(data).to eq({ "hello" => "foo" })
     end
 
-    it "should strict_set shallow string value" do
-      str = "[hello]"
-      data = {}
-      accessors = LogStash::Util::Accessors.new(data)
-      expect(accessors.strict_set(str, "foo")).to eq("foo")
-      expect(data).to eq({ "hello" => "foo"})
-    end
-
     it "should set deep string value" do
       str = "[hello][world]"
       data = {}
@@ -145,14 +137,6 @@ describe LogStash::Util::Accessors, :if => true do
       expect(data).to eq({ "hello" => { "world" => ["foo", "bar"] } })
     end
 
-    it "should strict_set deep array value" do
-      str = "[hello][world]"
-      data = {}
-      accessors = LogStash::Util::Accessors.new(data)
-      expect(accessors.strict_set(str, ["foo", "bar"]) ).to eq(["foo", "bar"])
-      expect(data).to eq({ "hello" => { "world" => ["foo", "bar"] } })
-    end
-
     it "should set element within array value" do
       str = "[hello][0]"
       data = {"hello" => ["foo", "bar"]}
@@ -181,35 +165,6 @@ describe LogStash::Util::Accessors, :if => true do
       accessors = LogStash::Util::Accessors.new(data)
       expect(accessors.del(str)).to eq(4)
       expect(data).to eq({ "geocoords" => [2] })
-    end  end
-
-  context "using invalid encoding" do
-    it "strinct_set should raise on non UTF-8 string encoding" do
-      str = "[hello]"
-      data = {}
-      accessors = LogStash::Util::Accessors.new(data)
-      expect { accessors.strict_set(str, "foo".encode("US-ASCII")) }.to raise_error
-    end
-
-    it "strinct_set should raise on non UTF-8 string encoding in array" do
-      str = "[hello]"
-      data = {}
-      accessors = LogStash::Util::Accessors.new(data)
-      expect { accessors.strict_set(str, ["foo", "bar".encode("US-ASCII")]) }.to raise_error
-    end
-
-    it "strinct_set should raise on invalid UTF-8 string encoding" do
-      str = "[hello]"
-      data = {}
-      accessors = LogStash::Util::Accessors.new(data)
-      expect { accessors.strict_set(str, "foo \xED\xB9\x81\xC3") }.to raise_error
-    end
-
-    it "strinct_set should raise on invalid UTF-8 string encoding in array" do
-      str = "[hello]"
-      data = {}
-      accessors = LogStash::Util::Accessors.new(data)
-      expect { accessors.strict_set(str, ["foo", "bar \xED\xB9\x81\xC3"]) }.to raise_error
     end
   end
 end

data/spec/util/json_spec.rb

@@ -4,7 +4,7 @@ require "logstash/json"
 require "logstash/environment"
 require "logstash/util"
 
-describe LogStash::Json do
+describe "LogStash::Json" do
 
   let(:hash)   {{"a" => 1}}
   let(:json_hash)   {"{\"a\":1}"}
@@ -33,27 +33,26 @@ describe LogStash::Json do
   if LogStash::Environment.jruby?
 
     ### JRuby specific
-
+    # Former expectation in this code were removed because of https://github.com/rspec/rspec-mocks/issues/964
+    # as soon as is fix we can re introduce them if decired, however for now the completeness of the test
+    # is also not affected as the conversion would not work if the expectation where not meet.
+    ###
     context "jruby deserialize" do
       it "should respond to load and deserialize object" do
-        expect(JrJackson::Raw).to receive(:parse_raw).with(json_hash).and_call_original
         expect(LogStash::Json.load(json_hash)).to eql(hash)
       end
     end
 
     context "jruby serialize" do
       it "should respond to dump and serialize object" do
-        expect(JrJackson::Json).to receive(:dump).with(string).and_call_original
         expect(LogStash::Json.dump(string)).to eql(json_string)
       end
 
       it "should call JrJackson::Raw.generate for Hash" do
-        expect(JrJackson::Raw).to receive(:generate).with(hash).and_call_original
         expect(LogStash::Json.dump(hash)).to eql(json_hash)
       end
 
       it "should call JrJackson::Raw.generate for Array" do
-        expect(JrJackson::Raw).to receive(:generate).with(array).and_call_original
         expect(LogStash::Json.dump(array)).to eql(json_array)
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logstash-core
 version: !ruby/object:Gem::Version
-  version: 1.5.0.snapshot1
+  version: 1.5.1
 platform: java
 authors:
 - Jordan Sissel
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-05-11 00:00:00.000000000 Z
+date: 2015-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cabin
@@ -124,6 +124,20 @@ dependencies:
         version: 0.5.4
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
   name: jrjackson
   version_requirements: !ruby/object:Gem::Requirement
@@ -233,9 +247,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
 rubygems_version: 2.2.2