logstash-core-event 2.4.1-java → 5.0.0.alpha1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba9fbf95bbe0efc36fafc65e5d5a8cae772c65b1
-  data.tar.gz: 0555aa1d3644bb493ff50b1283eb4767d24aacd5
+  metadata.gz: d1657c518f042a78ddbfcef66ec47f9ede82251a
+  data.tar.gz: a09cd95fe9f34ff2be9db7c3257011f291f22d43
 SHA512:
-  metadata.gz: ccfa5f374252a9bd0a0843c3335f0f6010f963deeba62c0fc9d845e9c5e41e3c5b107c63d6f3d4ac9bca92b7c8c90b2c490c2e5e97875270b11a75b952d7ad1c
-  data.tar.gz: 5e235d8f6bc1b9ff04b46e3d42be0b6cd2b8683b8bfb9a282b5e2b2791133f67e64d7410f4238810f8db8086a1934c312c527cc4efe3f7829d87e3d94aab4e52
+  metadata.gz: ab09ee15f5438e6b6dbbfe7674a2c1992d99a188c2fde7385fdc0fbd89099f9320747e49c09ef6de6c0ea5d228c8bea929ced2fe0d2cc43f3c18919bcff29be8
+  data.tar.gz: e291fc3fde667587e91d8d64c1ad4e9c9908834a2b880428be82bb4b4896c9cd9f13d74f79b941c0064ed1174700119deef1d5f2f35bcea0d5d72471bc18cdaa

data/lib/logstash-core-event/version.rb

@@ -5,4 +5,4 @@
 # Note to authors: this should not include dashes because 'gem' barfs if
 # you include a dash in the version string.
 
-LOGSTASH_CORE_EVENT_VERSION = "2.4.1"
+LOGSTASH_CORE_EVENT_VERSION = "5.0.0-alpha1"

data/lib/logstash/event.rb

@@ -113,7 +113,7 @@ class LogStash::Event
     @data[TIMESTAMP] = val
   end
 
-  def get(fieldref)
+  def [](fieldref)
     if fieldref.start_with?(METADATA_BRACKETS)
       @metadata_accessors.get(fieldref[METADATA_BRACKETS.length .. -1])
     elsif fieldref == METADATA
@@ -123,7 +123,7 @@ class LogStash::Event
     end
   end
 
-  def set(fieldref, value)
+  def []=(fieldref, value)
     if fieldref == TIMESTAMP && !value.is_a?(LogStash::Timestamp)
       raise TypeError, "The field '@timestamp' must be a (LogStash::Timestamp, not a #{value.class} (#{value})"
     end
@@ -137,9 +137,6 @@ class LogStash::Event
     end
   end
 
-  alias_method :[], :get
-  alias_method :[]=, :set
-
   def to_json(*args)
     # ignore arguments to respect accepted to_json method signature
     LogStash::Json.dump(@data)

data/lib/logstash/string_interpolation.rb

@@ -124,15 +124,9 @@ module LogStash
         value.join(",")
       when Hash
         LogStash::Json.dump(value)
-      when Numeric
-        value
-      when TrueClass
-        value
-      when FalseClass
-        value
       else
-        # If we dont know how to deal with the type we return a string
-        # to make sure we don't return a reference.
+        # Make sure we dont work on the refence of the value
+        # The Java Event implementation was always returning a string.
         "#{value}"
       end
     end

data/lib/logstash/timestamp.rb

@@ -24,13 +24,7 @@ module LogStash
     end
 
     def self.at(*args)
-      epoch = args.first
-      if epoch.is_a?(BigDecimal)
-        # bug in JRuby prevents correcly parsing a BigDecimal fractional part, see https://github.com/elastic/logstash/issues/4565
-        Timestamp.new(::Time.at(epoch.to_i, epoch.frac.to_f * 1000000))
-      else
-        Timestamp.new(::Time.at(*args))
-      end
+      Timestamp.new(::Time.at(*args))
     end
 
     def self.parse(*args)

data/lib/logstash/util/accessors.rb

@@ -95,14 +95,7 @@ module LogStash::Util
     # @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)
-      # flush the @lut to prevent stale cached fieldref which may point to an old target
-      # which was overwritten with a new value. for example, if "[a][b]" is cached and we
-      # set a new value for "[a]" then reading again "[a][b]" would point in a stale target.
-      # flushing the complete @lut is suboptimal, but a hierarchical lut would be required
-      # to be able to invalidate fieldrefs from a common root.
-      # see https://github.com/elastic/logstash/pull/5132
-      @lut.clear
-      @lut[field_reference] = find_or_create_target(field_reference)
+      @lut[field_reference] ||= find_or_create_target(field_reference)
     end
 
     # find the target container object in store for this field reference

data/logstash-core-event.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "logstash-core-event"
   gem.require_paths = ["lib"]
-  gem.version       = LOGSTASH_CORE_EVENT_VERSION
+  gem.version       = LOGSTASH_CORE_EVENT_VERSION.gsub(/-/, '.')
 
   if RUBY_PLATFORM == 'java'
     gem.platform = RUBY_PLATFORM

data/spec/logstash/event_spec.rb

@@ -8,68 +8,68 @@ describe LogStash::Event do
   shared_examples "all event tests" do
     context "[]=" do
       it "should raise an exception if you attempt to set @timestamp to a value type other than a Time object" do
-        expect{subject.set("@timestamp", "crash!")}.to raise_error(TypeError)
+        expect{subject["@timestamp"] = "crash!"}.to raise_error(TypeError)
       end
 
       it "should assign simple fields" do
-        expect(subject.get("foo")).to be_nil
-        expect(subject.set("foo", "bar")).to eq("bar")
-        expect(subject.get("foo")).to eq("bar")
+        expect(subject["foo"]).to be_nil
+        expect(subject["foo"] = "bar").to eq("bar")
+        expect(subject["foo"]).to eq("bar")
       end
 
       it "should overwrite simple fields" do
-        expect(subject.get("foo")).to be_nil
-        expect(subject.set("foo", "bar")).to eq("bar")
-        expect(subject.get("foo")).to eq("bar")
+        expect(subject["foo"]).to be_nil
+        expect(subject["foo"] = "bar").to eq("bar")
+        expect(subject["foo"]).to eq("bar")
 
-        expect(subject.set("foo", "baz")).to eq("baz")
-        expect(subject.get("foo")).to eq("baz")
+        expect(subject["foo"] = "baz").to eq("baz")
+        expect(subject["foo"]).to eq("baz")
       end
 
       it "should assign deep fields" do
-        expect(subject.get("[foo][bar]")).to be_nil
-        expect(subject.set("[foo][bar]", "baz")).to eq("baz")
-        expect(subject.get("[foo][bar]")).to eq("baz")
+        expect(subject["[foo][bar]"]).to be_nil
+        expect(subject["[foo][bar]"] = "baz").to eq("baz")
+        expect(subject["[foo][bar]"]).to eq("baz")
       end
 
       it "should overwrite deep fields" do
-        expect(subject.get("[foo][bar]")).to be_nil
-        expect(subject.set("[foo][bar]", "baz")).to eq("baz")
-        expect(subject.get("[foo][bar]")).to eq("baz")
+        expect(subject["[foo][bar]"]).to be_nil
+        expect(subject["[foo][bar]"] = "baz").to eq("baz")
+        expect(subject["[foo][bar]"]).to eq("baz")
 
-        expect(subject.set("[foo][bar]", "zab")).to eq("zab")
-        expect(subject.get("[foo][bar]")).to eq("zab")
+        expect(subject["[foo][bar]"] = "zab").to eq("zab")
+        expect(subject["[foo][bar]"]).to eq("zab")
       end
 
       it "allow to set the @metadata key to a hash" do
-        subject.set("@metadata", { "action" => "index" })
-        expect(subject.get("[@metadata][action]")).to eq("index")
+        subject["@metadata"] = { "action" => "index" }
+        expect(subject["[@metadata][action]"]).to eq("index")
       end
 
       it "should add key when setting nil value" do
-        subject.set("[baz]", nil)
+        subject["[baz]"] = nil
         expect(subject.to_hash).to include("baz" => nil)
       end
 
       it "should set nil element within existing array value" do
-        subject.set("[foo]", ["bar", "baz"])
+        subject["[foo]"] = ["bar", "baz"]
 
-        expect(subject.set("[foo][0]", nil)).to eq(nil)
-        expect(subject.get("[foo]")).to eq([nil, "baz"])
+        expect(subject["[foo][0]"] = nil).to eq(nil)
+        expect(subject["[foo]"]).to eq([nil, "baz"])
       end
 
       it "should set nil in first element within empty array" do
-        subject.set("[foo]", [])
+        subject["[foo]"] = []
 
-        expect(subject.set("[foo][0]", nil)).to eq(nil)
-        expect(subject.get("[foo]")).to eq([nil])
+        expect(subject["[foo][0]"] = nil).to eq(nil)
+        expect(subject["[foo]"]).to eq([nil])
       end
 
       it "should set nil in second element within empty array" do
-        subject.set("[foo]", [])
+        subject["[foo]"] = []
 
-        expect(subject.set("[foo][1]", nil)).to eq(nil)
-        expect(subject.get("[foo]")).to eq([nil, nil])
+        expect(subject["[foo][1]"] = nil).to eq(nil)
+        expect(subject["[foo]"]).to eq([nil, nil])
       end
     end
 
@@ -79,43 +79,15 @@ describe LogStash::Event do
         event = LogStash::Event.new({ "reference" => data })
         LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
         data.downcase!
-        expect(event.get("reference_test")).not_to eq(data)
+        expect(event["reference_test"]).not_to eq(data)
       end
 
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return a Fixnum" do
+      it "should not return a Fixnum reference" do
         data = 1
         event = LogStash::Event.new({ "reference" => data })
         LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event.get("reference_test")).to eq(1)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return a Float" do
-        data = 1.999
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event.get("reference_test")).to eq(1.999)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return true" do
-        data = true
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event.get("reference_test")).to be_kind_of(TrueClass)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return false" do
-        data = false
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event.get("reference_test")).to be_kind_of(FalseClass)
+        data += 41
+        expect(event["reference_test"]).to eq("1")
       end
 
       it "should report a unix timestamp for %{+%s}" do
@@ -152,7 +124,7 @@ describe LogStash::Event do
 
       it "should report fields with %{field} syntax" do
         expect(subject.sprintf("%{type}")).to eq("sprintf")
-        expect(subject.sprintf("%{message}")).to eq(subject.get("message"))
+        expect(subject.sprintf("%{message}")).to eq(subject["message"])
       end
 
       it "should print deep fields" do
@@ -181,35 +153,35 @@ describe LogStash::Event do
       end
 
       it "should render nil array values as leading empty string" do
-        expect(subject.set("foo", [nil, "baz"])).to eq([nil, "baz"])
+        expect(subject["foo"] = [nil, "baz"]).to eq([nil, "baz"])
 
-        expect(subject.get("[foo][0]")).to be_nil
-        expect(subject.get("[foo][1]")).to eq("baz")
+        expect(subject["[foo][0]"]).to be_nil
+        expect(subject["[foo][1]"]).to eq("baz")
 
         expect(subject.sprintf("%{[foo]}")).to eq(",baz")
       end
 
       it "should render nil array values as middle empty string" do
-        expect(subject.set("foo", ["bar", nil, "baz"])).to eq(["bar", nil, "baz"])
+        expect(subject["foo"] = ["bar", nil, "baz"]).to eq(["bar", nil, "baz"])
 
-        expect(subject.get("[foo][0]")).to eq("bar")
-        expect(subject.get("[foo][1]")).to be_nil
-        expect(subject.get("[foo][2]")).to eq("baz")
+        expect(subject["[foo][0]"]).to eq("bar")
+        expect(subject["[foo][1]"]).to be_nil
+        expect(subject["[foo][2]"]).to eq("baz")
 
         expect(subject.sprintf("%{[foo]}")).to eq("bar,,baz")
       end
 
      it "should render nil array values as trailing empty string" do
-        expect(subject.set("foo", ["bar", nil])).to eq(["bar", nil])
+        expect(subject["foo"] = ["bar", nil]).to eq(["bar", nil])
 
-        expect(subject.get("[foo][0]")).to eq("bar")
-        expect(subject.get("[foo][1]")).to be_nil
+        expect(subject["[foo][0]"]).to eq("bar")
+        expect(subject["[foo][1]"]).to be_nil
 
         expect(subject.sprintf("%{[foo]}")).to eq("bar,")
      end
 
       it "should render deep arrays with nil value" do
-        subject.set("[foo]", [[12, nil], 56])
+        subject["[foo]"] = [[12, nil], 56]
         expect(subject.sprintf("%{[foo]}")).to eq("12,,56")
       end
 
@@ -226,18 +198,18 @@ describe LogStash::Event do
 
     context "#[]" do
       it "should fetch data" do
-        expect(subject.get("type")).to eq("sprintf")
+        expect(subject["type"]).to eq("sprintf")
       end
       it "should fetch fields" do
-        expect(subject.get("a")).to eq("b")
-        expect(subject.get('c')['d']).to eq("f")
+        expect(subject["a"]).to eq("b")
+        expect(subject['c']['d']).to eq("f")
       end
       it "should fetch deep fields" do
-        expect(subject.get("[j][k1]")).to eq("v")
-        expect(subject.get("[c][d]")).to eq("f")
-        expect(subject.get('[f][g][h]')).to eq("i")
-        expect(subject.get('[j][k3][4]')).to eq("m")
-        expect(subject.get('[j][5]')).to eq(7)
+        expect(subject["[j][k1]"]).to eq("v")
+        expect(subject["[c][d]"]).to eq("f")
+        expect(subject['[f][g][h]']).to eq("i")
+        expect(subject['[j][k3][4]']).to eq("m")
+        expect(subject['[j][5]']).to eq(7)
 
       end
 
@@ -245,7 +217,7 @@ describe LogStash::Event do
         count = 1000000
         2.times do
           start = Time.now
-          count.times { subject.get("[j][k1]") }
+          count.times { subject["[j][k1]"] }
           duration = Time.now - start
           puts "event #[] rate: #{"%02.0f/sec" % (count / duration)}, elapsed: #{duration}s"
         end
@@ -291,11 +263,11 @@ describe LogStash::Event do
         )
         subject.overwrite(new_event)
 
-        expect(subject.get("message")).to eq("foo bar")
-        expect(subject.get("type")).to eq("new")
+        expect(subject["message"]).to eq("foo bar")
+        expect(subject["type"]).to eq("new")
 
         ["tags", "source", "a", "c", "f", "j"].each do |field|
-          expect(subject.get(field)).to be_nil
+          expect(subject[field]).to be_nil
         end
       end
     end
@@ -303,7 +275,7 @@ describe LogStash::Event do
     context "#append" do
       it "should append strings to an array" do
         subject.append(LogStash::Event.new("message" => "another thing"))
-        expect(subject.get("message")).to eq([ "hello world", "another thing" ])
+        expect(subject["message"]).to eq([ "hello world", "another thing" ])
       end
 
       it "should concatenate tags" do
@@ -311,54 +283,54 @@ describe LogStash::Event do
         # added to_a for when array is a Java Collection when produced from json input
         # TODO: we have to find a better way to handle this in tests. maybe override
         # rspec eq or == to do an explicit to_a when comparing arrays?
-        expect(subject.get("tags").to_a).to eq([ "tag1", "tag2" ])
+        expect(subject["tags"].to_a).to eq([ "tag1", "tag2" ])
       end
 
       context "when event field is nil" do
         it "should add single value as string" do
           subject.append(LogStash::Event.new({"field1" => "append1"}))
-          expect(subject.get("field1")).to eq("append1")
+          expect(subject[ "field1" ]).to eq("append1")
         end
         it "should add multi values as array" do
           subject.append(LogStash::Event.new({"field1" => [ "append1","append2" ]}))
-          expect(subject.get("field1")).to eq([ "append1","append2" ])
+          expect(subject[ "field1" ]).to eq([ "append1","append2" ])
         end
       end
 
       context "when event field is a string" do
-        before { subject.set("field1", "original1") }
+        before { subject[ "field1" ] = "original1" }
 
         it "should append string to values, if different from current" do
           subject.append(LogStash::Event.new({"field1" => "append1"}))
-          expect(subject.get("field1")).to eq([ "original1", "append1" ])
+          expect(subject[ "field1" ]).to eq([ "original1", "append1" ])
         end
         it "should not change value, if appended value is equal current" do
           subject.append(LogStash::Event.new({"field1" => "original1"}))
-          expect(subject.get("field1")).to eq("original1")
+          expect(subject[ "field1" ]).to eq("original1")
         end
         it "should concatenate values in an array" do
           subject.append(LogStash::Event.new({"field1" => [ "append1" ]}))
-          expect(subject.get("field1")).to eq([ "original1", "append1" ])
+          expect(subject[ "field1" ]).to eq([ "original1", "append1" ])
         end
         it "should join array, removing duplicates" do
           subject.append(LogStash::Event.new({"field1" => [ "append1","original1" ]}))
-          expect(subject.get("field1")).to eq([ "original1", "append1" ])
+          expect(subject[ "field1" ]).to eq([ "original1", "append1" ])
         end
       end
       context "when event field is an array" do
-        before { subject.set("field1", [ "original1", "original2" ] )}
+        before { subject[ "field1" ] = [ "original1", "original2" ] }
 
         it "should append string values to array, if not present in array" do
           subject.append(LogStash::Event.new({"field1" => "append1"}))
-          expect(subject.get("field1")).to eq([ "original1", "original2", "append1" ])
+          expect(subject[ "field1" ]).to eq([ "original1", "original2", "append1" ])
         end
         it "should not append string values, if the array already contains it" do
           subject.append(LogStash::Event.new({"field1" => "original1"}))
-          expect(subject.get("field1")).to eq([ "original1", "original2" ])
+          expect(subject[ "field1" ]).to eq([ "original1", "original2" ])
         end
         it "should join array, removing duplicates" do
           subject.append(LogStash::Event.new({"field1" => [ "append1","original1" ]}))
-          expect(subject.get("field1")).to eq([ "original1", "original2", "append1" ])
+          expect(subject[ "field1" ]).to eq([ "original1", "original2", "append1" ])
         end
       end
 
@@ -370,7 +342,7 @@ describe LogStash::Event do
 
       data = { "@timestamp" => "2013-12-21T07:25:06.605Z" }
       event = LogStash::Event.new(data)
-      expect(event.get("@timestamp")).to be_a(LogStash::Timestamp)
+      expect(event["@timestamp"]).to be_a(LogStash::Timestamp)
 
       duration = 0
       [warmup, count].each do |i|
@@ -439,13 +411,13 @@ describe LogStash::Event do
       it "should tag for invalid value" do
         event = LogStash::Event.new("@timestamp" => "foo")
         expect(event.timestamp.to_i).to be_within(1).of Time.now.to_i
-        expect(event.get("tags")).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
-        expect(event.get(LogStash::Event::TIMESTAMP_FAILURE_FIELD)).to eq("foo")
+        expect(event["tags"]).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
+        expect(event[LogStash::Event::TIMESTAMP_FAILURE_FIELD]).to eq("foo")
 
         event = LogStash::Event.new("@timestamp" => 666)
         expect(event.timestamp.to_i).to be_within(1).of Time.now.to_i
-        expect(event.get("tags")).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
-        expect(event.get(LogStash::Event::TIMESTAMP_FAILURE_FIELD)).to eq(666)
+        expect(event["tags"]).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
+        expect(event[LogStash::Event::TIMESTAMP_FAILURE_FIELD]).to eq(666)
       end
 
       it "should warn for invalid value" do
@@ -460,8 +432,8 @@ describe LogStash::Event do
       it "should tag for invalid string format" do
         event = LogStash::Event.new("@timestamp" => "foo")
         expect(event.timestamp.to_i).to be_within(1).of Time.now.to_i
-        expect(event.get("tags")).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
-        expect(event.get(LogStash::Event::TIMESTAMP_FAILURE_FIELD)).to eq("foo")
+        expect(event["tags"]).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
+        expect(event[LogStash::Event::TIMESTAMP_FAILURE_FIELD]).to eq("foo")
       end
 
       it "should warn for invalid string format" do
@@ -506,7 +478,7 @@ describe LogStash::Event do
         end
 
         it "should still allow normal field access" do
-          expect(subject.get("hello")).to eq("world")
+          expect(subject["hello"]).to eq("world")
         end
       end
 
@@ -519,15 +491,15 @@ describe LogStash::Event do
           expect(fieldref).to start_with("[@metadata]")
 
           # Set it.
-          subject.set(fieldref, value)
+          subject[fieldref] = value
         end
 
         it "should still allow normal field access" do
-          expect(subject.get("normal")).to eq("normal")
+          expect(subject["normal"]).to eq("normal")
         end
 
         it "should allow getting" do
-          expect(subject.get(fieldref)).to eq(value)
+          expect(subject[fieldref]).to eq(value)
         end
 
         it "should be hidden from .to_json" do
@@ -550,10 +522,10 @@ describe LogStash::Event do
       context "with no metadata" do
         subject { LogStash::Event.new("foo" => "bar") }
         it "should have no metadata" do
-          expect(subject.get("@metadata")).to be_empty
+          expect(subject["@metadata"]).to be_empty
         end
         it "should still allow normal field access" do
-          expect(subject.get("foo")).to eq("bar")
+          expect(subject["foo"]).to eq("bar")
         end
 
         it "should not include the @metadata key" do
@@ -627,35 +599,7 @@ describe LogStash::Event do
     end
 
     it "return the string containing the timestamp, the host and the message" do
-      expect(event1.to_s).to eq("#{timestamp.to_iso8601} #{event1.get("host")} #{event1.get("message")}")
-    end
-  end
-
-  describe "Event accessors" do
-    let(:event) { LogStash::Event.new({ "message" => "foo" }) }
-
-    it "should invalidate target caching" do
-      expect(event.get("[a][0]")).to be_nil
-
-      expect(event.set("[a][0]", 42)).to eq(42)
-      expect(event.get("[a][0]")).to eq(42)
-      expect(event.get("[a]")).to eq({"0" => 42})
-
-      expect(event.set("[a]", [42, 24])).to eq([42, 24])
-      expect(event.get("[a]")).to eq([42, 24])
-
-      expect(event.get("[a][0]")).to eq(42)
-
-      expect(event.set("[a]", [24, 42])).to eq([24, 42])
-      expect(event.get("[a][0]")).to eq(24)
-
-      expect(event.set("[a][0]", {"a "=> 99, "b" => 98})).to eq({"a "=> 99, "b" => 98})
-      expect(event.get("[a][0]")).to eq({"a "=> 99, "b" => 98})
-
-      expect(event.get("[a]")).to eq([{"a "=> 99, "b" => 98}, 42])
-      expect(event.get("[a][0]")).to eq({"a "=> 99, "b" => 98})
-      expect(event.get("[a][1]")).to eq(42)
-      expect(event.get("[a][0][b]")).to eq(98)
+      expect(event1.to_s).to eq("#{timestamp.to_iso8601} #{event1["host"]} #{event1["message"]}")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-core-event
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 5.0.0.alpha1
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-11-07 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies: []
 description: The core event component of logstash, the scalable log and event management tool
 email:
@@ -25,7 +25,6 @@ files:
 - lib/logstash/timestamp.rb
 - lib/logstash/util/accessors.rb
 - logstash-core-event.gemspec
-- spec/logstash/event_old_api_spec.rb
 - spec/logstash/event_spec.rb
 - spec/logstash/timestamp_spec.rb
 - spec/logstash/util/accessors_spec.rb
@@ -44,9 +43,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project:
 rubygems_version: 2.4.8
@@ -54,7 +53,6 @@ signing_key:
 specification_version: 4
 summary: logstash-core-event - The core event component of logstash
 test_files:
-- spec/logstash/event_old_api_spec.rb
 - spec/logstash/event_spec.rb
 - spec/logstash/timestamp_spec.rb
 - spec/logstash/util/accessors_spec.rb

data/spec/logstash/event_old_api_spec.rb

@@ -1,662 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require "logstash/util/decorators"
-require "json"
-
-describe LogStash::Event do
-
-  shared_examples "all event tests" do
-    context "[]=" do
-      it "should raise an exception if you attempt to set @timestamp to a value type other than a Time object" do
-        expect{subject["@timestamp"] = "crash!"}.to raise_error(TypeError)
-      end
-
-      it "should assign simple fields" do
-        expect(subject["foo"]).to be_nil
-        expect(subject["foo"] = "bar").to eq("bar")
-        expect(subject["foo"]).to eq("bar")
-      end
-
-      it "should overwrite simple fields" do
-        expect(subject["foo"]).to be_nil
-        expect(subject["foo"] = "bar").to eq("bar")
-        expect(subject["foo"]).to eq("bar")
-
-        expect(subject["foo"] = "baz").to eq("baz")
-        expect(subject["foo"]).to eq("baz")
-      end
-
-      it "should assign deep fields" do
-        expect(subject["[foo][bar]"]).to be_nil
-        expect(subject["[foo][bar]"] = "baz").to eq("baz")
-        expect(subject["[foo][bar]"]).to eq("baz")
-      end
-
-      it "should overwrite deep fields" do
-        expect(subject["[foo][bar]"]).to be_nil
-        expect(subject["[foo][bar]"] = "baz").to eq("baz")
-        expect(subject["[foo][bar]"]).to eq("baz")
-
-        expect(subject["[foo][bar]"] = "zab").to eq("zab")
-        expect(subject["[foo][bar]"]).to eq("zab")
-      end
-
-      it "allow to set the @metadata key to a hash" do
-        subject["@metadata"] = { "action" => "index" }
-        expect(subject["[@metadata][action]"]).to eq("index")
-      end
-
-      it "should add key when setting nil value" do
-        subject["[baz]"] = nil
-        expect(subject.to_hash).to include("baz" => nil)
-      end
-
-      it "should set nil element within existing array value" do
-        subject["[foo]"] = ["bar", "baz"]
-
-        expect(subject["[foo][0]"] = nil).to eq(nil)
-        expect(subject["[foo]"]).to eq([nil, "baz"])
-      end
-
-      it "should set nil in first element within empty array" do
-        subject["[foo]"] = []
-
-        expect(subject["[foo][0]"] = nil).to eq(nil)
-        expect(subject["[foo]"]).to eq([nil])
-      end
-
-      it "should set nil in second element within empty array" do
-        subject["[foo]"] = []
-
-        expect(subject["[foo][1]"] = nil).to eq(nil)
-        expect(subject["[foo]"]).to eq([nil, nil])
-      end
-    end
-
-    context "#sprintf" do
-      it "should not return a String reference" do
-        data = "NOT-A-REFERENCE"
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        data.downcase!
-        expect(event["reference_test"]).not_to eq(data)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return a Fixnum" do
-        data = 1
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event["reference_test"]).to eq(1)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return a Float" do
-        data = 1.999
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event["reference_test"]).to eq(1.999)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return true" do
-        data = true
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event["reference_test"]).to be_kind_of(TrueClass)
-      end
-
-      # TODO: This was a bug and should only be true in the context of 2.3.X
-      # see https://github.com/elastic/logstash/issues/5114 for more details.
-      it "should return false" do
-        data = false
-        event = LogStash::Event.new({ "reference" => data })
-        LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
-        expect(event["reference_test"]).to be_kind_of(FalseClass)
-      end
-
-      it "should report a unix timestamp for %{+%s}" do
-        expect(subject.sprintf("%{+%s}")).to eq("1356998400")
-      end
-
-      it "should work if there is no fieldref in the string" do
-        expect(subject.sprintf("bonjour")).to eq("bonjour")
-      end
-
-      it "should raise error when formatting %{+%s} when @timestamp field is missing" do
-        str = "hello-%{+%s}"
-        subj = subject.clone
-        subj.remove("[@timestamp]")
-        expect{ subj.sprintf(str) }.to raise_error(LogStash::Error)
-      end
-
-      it "should report a time with %{+format} syntax", :if => RUBY_ENGINE == "jruby" do
-        expect(subject.sprintf("%{+YYYY}")).to eq("2013")
-        expect(subject.sprintf("%{+MM}")).to eq("01")
-        expect(subject.sprintf("%{+HH}")).to eq("00")
-      end
-
-      it "should support mixed string" do
-        expect(subject.sprintf("foo %{+YYYY-MM-dd} %{type}")).to eq("foo 2013-01-01 sprintf")
-      end
-
-      it "should raise error with %{+format} syntax when @timestamp field is missing", :if => RUBY_ENGINE == "jruby" do
-        str = "logstash-%{+YYYY}"
-        subj = subject.clone
-        subj.remove("[@timestamp]")
-        expect{ subj.sprintf(str) }.to raise_error(LogStash::Error)
-      end
-
-      it "should report fields with %{field} syntax" do
-        expect(subject.sprintf("%{type}")).to eq("sprintf")
-        expect(subject.sprintf("%{message}")).to eq(subject["message"])
-      end
-
-      it "should print deep fields" do
-        expect(subject.sprintf("%{[j][k1]}")).to eq("v")
-        expect(subject.sprintf("%{[j][k2][0]}")).to eq("w")
-      end
-
-      it "should be able to take a non-string for the format" do
-        expect(subject.sprintf(2)).to eq("2")
-      end
-
-      it "should allow to use the metadata when calling #sprintf" do
-        expect(subject.sprintf("super-%{[@metadata][fancy]}")).to eq("super-pants")
-      end
-
-      it "should allow to use nested hash from the metadata field" do
-        expect(subject.sprintf("%{[@metadata][have-to-go][deeper]}")).to eq("inception")
-      end
-
-      it "should return a json string if the key is a hash" do
-        expect(subject.sprintf("%{[j][k3]}")).to eq("{\"4\":\"m\"}")
-      end
-
-      it "should not strip last character" do
-        expect(subject.sprintf("%{type}%{message}|")).to eq("sprintfhello world|")
-      end
-
-      it "should render nil array values as leading empty string" do
-        expect(subject["foo"] = [nil, "baz"]).to eq([nil, "baz"])
-
-        expect(subject["[foo][0]"]).to be_nil
-        expect(subject["[foo][1]"]).to eq("baz")
-
-        expect(subject.sprintf("%{[foo]}")).to eq(",baz")
-      end
-
-      it "should render nil array values as middle empty string" do
-        expect(subject["foo"] = ["bar", nil, "baz"]).to eq(["bar", nil, "baz"])
-
-        expect(subject["[foo][0]"]).to eq("bar")
-        expect(subject["[foo][1]"]).to be_nil
-        expect(subject["[foo][2]"]).to eq("baz")
-
-        expect(subject.sprintf("%{[foo]}")).to eq("bar,,baz")
-      end
-
-     it "should render nil array values as trailing empty string" do
-        expect(subject["foo"] = ["bar", nil]).to eq(["bar", nil])
-
-        expect(subject["[foo][0]"]).to eq("bar")
-        expect(subject["[foo][1]"]).to be_nil
-
-        expect(subject.sprintf("%{[foo]}")).to eq("bar,")
-     end
-
-      it "should render deep arrays with nil value" do
-        subject["[foo]"] = [[12, nil], 56]
-        expect(subject.sprintf("%{[foo]}")).to eq("12,,56")
-      end
-
-      context "#encoding" do
-        it "should return known patterns as UTF-8" do
-          expect(subject.sprintf("%{message}").encoding).to eq(Encoding::UTF_8)
-        end
-
-        it "should return unknown patterns as UTF-8" do
-          expect(subject.sprintf("%{unkown_pattern}").encoding).to eq(Encoding::UTF_8)
-        end
-      end
-    end
-
-    context "#[]" do
-      it "should fetch data" do
-        expect(subject["type"]).to eq("sprintf")
-      end
-      it "should fetch fields" do
-        expect(subject["a"]).to eq("b")
-        expect(subject['c']['d']).to eq("f")
-      end
-      it "should fetch deep fields" do
-        expect(subject["[j][k1]"]).to eq("v")
-        expect(subject["[c][d]"]).to eq("f")
-        expect(subject['[f][g][h]']).to eq("i")
-        expect(subject['[j][k3][4]']).to eq("m")
-        expect(subject['[j][5]']).to eq(7)
-
-      end
-
-      it "should be fast?", :performance => true do
-        count = 1000000
-        2.times do
-          start = Time.now
-          count.times { subject["[j][k1]"] }
-          duration = Time.now - start
-          puts "event #[] rate: #{"%02.0f/sec" % (count / duration)}, elapsed: #{duration}s"
-        end
-      end
-    end
-
-    context "#include?" do
-      it "should include existing fields" do
-        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 eq(true)
-      end
-
-      it "should include @metadata field" do
-        expect(subject.include?("@metadata")).to eq(true)
-      end
-
-      it "should include field within @metadata" do
-        expect(subject.include?("[@metadata][fancy]")).to eq(true)
-      end
-
-      it "should not include non-existing fields" do
-        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 eq(true)
-        expect(subject.include?("[tags][1]")).to eq(false)
-      end
-    end
-
-    context "#overwrite" do
-      it "should swap data with new content" do
-        new_event = LogStash::Event.new(
-          "type" => "new",
-          "message" => "foo bar",
-        )
-        subject.overwrite(new_event)
-
-        expect(subject["message"]).to eq("foo bar")
-        expect(subject["type"]).to eq("new")
-
-        ["tags", "source", "a", "c", "f", "j"].each do |field|
-          expect(subject[field]).to be_nil
-        end
-      end
-    end
-
-    context "#append" do
-      it "should append strings to an array" do
-        subject.append(LogStash::Event.new("message" => "another thing"))
-        expect(subject["message"]).to eq([ "hello world", "another thing" ])
-      end
-
-      it "should concatenate tags" do
-        subject.append(LogStash::Event.new("tags" => [ "tag2" ]))
-        # added to_a for when array is a Java Collection when produced from json input
-        # TODO: we have to find a better way to handle this in tests. maybe override
-        # rspec eq or == to do an explicit to_a when comparing arrays?
-        expect(subject["tags"].to_a).to eq([ "tag1", "tag2" ])
-      end
-
-      context "when event field is nil" do
-        it "should add single value as string" do
-          subject.append(LogStash::Event.new({"field1" => "append1"}))
-          expect(subject[ "field1" ]).to eq("append1")
-        end
-        it "should add multi values as array" do
-          subject.append(LogStash::Event.new({"field1" => [ "append1","append2" ]}))
-          expect(subject[ "field1" ]).to eq([ "append1","append2" ])
-        end
-      end
-
-      context "when event field is a string" do
-        before { subject[ "field1" ] = "original1" }
-
-        it "should append string to values, if different from current" do
-          subject.append(LogStash::Event.new({"field1" => "append1"}))
-          expect(subject[ "field1" ]).to eq([ "original1", "append1" ])
-        end
-        it "should not change value, if appended value is equal current" do
-          subject.append(LogStash::Event.new({"field1" => "original1"}))
-          expect(subject[ "field1" ]).to eq("original1")
-        end
-        it "should concatenate values in an array" do
-          subject.append(LogStash::Event.new({"field1" => [ "append1" ]}))
-          expect(subject[ "field1" ]).to eq([ "original1", "append1" ])
-        end
-        it "should join array, removing duplicates" do
-          subject.append(LogStash::Event.new({"field1" => [ "append1","original1" ]}))
-          expect(subject[ "field1" ]).to eq([ "original1", "append1" ])
-        end
-      end
-      context "when event field is an array" do
-        before { subject[ "field1" ] = [ "original1", "original2" ] }
-
-        it "should append string values to array, if not present in array" do
-          subject.append(LogStash::Event.new({"field1" => "append1"}))
-          expect(subject[ "field1" ]).to eq([ "original1", "original2", "append1" ])
-        end
-        it "should not append string values, if the array already contains it" do
-          subject.append(LogStash::Event.new({"field1" => "original1"}))
-          expect(subject[ "field1" ]).to eq([ "original1", "original2" ])
-        end
-        it "should join array, removing duplicates" do
-          subject.append(LogStash::Event.new({"field1" => [ "append1","original1" ]}))
-          expect(subject[ "field1" ]).to eq([ "original1", "original2", "append1" ])
-        end
-      end
-
-    end
-
-    it "timestamp parsing speed", :performance => true do
-      warmup = 10000
-      count = 1000000
-
-      data = { "@timestamp" => "2013-12-21T07:25:06.605Z" }
-      event = LogStash::Event.new(data)
-      expect(event["@timestamp"]).to be_a(LogStash::Timestamp)
-
-      duration = 0
-      [warmup, count].each do |i|
-        start = Time.now
-        i.times do
-          data = { "@timestamp" => "2013-12-21T07:25:06.605Z" }
-          LogStash::Event.new(data.clone)
-        end
-        duration = Time.now - start
-      end
-      puts "event @timestamp parse rate: #{"%02.0f/sec" % (count / duration)}, elapsed: #{duration}s"
-    end
-
-    context "acceptable @timestamp formats" do
-      subject { LogStash::Event.new }
-
-      formats = [
-        "YYYY-MM-dd'T'HH:mm:ss.SSSZ",
-        "YYYY-MM-dd'T'HH:mm:ss.SSSSSSZ",
-        "YYYY-MM-dd'T'HH:mm:ss.SSS",
-        "YYYY-MM-dd'T'HH:mm:ss",
-        "YYYY-MM-dd'T'HH:mm:ssZ",
-      ]
-      formats.each do |format|
-        it "includes #{format}" do
-          time = subject.sprintf("%{+#{format}}")
-          begin
-            LogStash::Event.new("@timestamp" => time)
-          rescue => e
-            raise StandardError, "Time '#{time}' was rejected. #{e.class}: #{e.to_s}"
-          end
-        end
-      end
-
-      context "from LOGSTASH-1738" do
-        it "does not error" do
-          LogStash::Event.new("@timestamp" => "2013-12-29T23:12:52.371240+02:00")
-        end
-      end
-
-      context "from LOGSTASH-1732" do
-        it "does not error" do
-          LogStash::Event.new("@timestamp" => "2013-12-27T11:07:25+00:00")
-        end
-      end
-    end
-
-    context "timestamp initialization" do
-      let(:logger_mock) { double("logger") }
-
-      after(:each) do
-        LogStash::Event.logger = LogStash::Event::DEFAULT_LOGGER
-      end
-
-      it "should coerce timestamp" do
-        t = Time.iso8601("2014-06-12T00:12:17.114Z")
-        expect(LogStash::Event.new("@timestamp" => t).timestamp.to_i).to eq(t.to_i)
-        expect(LogStash::Event.new("@timestamp" => LogStash::Timestamp.new(t)).timestamp.to_i).to eq(t.to_i)
-        expect(LogStash::Event.new("@timestamp" => "2014-06-12T00:12:17.114Z").timestamp.to_i).to eq(t.to_i)
-      end
-
-      it "should assign current time when no timestamp" do
-        expect(LogStash::Event.new({}).timestamp.to_i).to be_within(1).of (Time.now.to_i)
-      end
-
-      it "should tag for invalid value" do
-        event = LogStash::Event.new("@timestamp" => "foo")
-        expect(event.timestamp.to_i).to be_within(1).of Time.now.to_i
-        expect(event["tags"]).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
-        expect(event[LogStash::Event::TIMESTAMP_FAILURE_FIELD]).to eq("foo")
-
-        event = LogStash::Event.new("@timestamp" => 666)
-        expect(event.timestamp.to_i).to be_within(1).of Time.now.to_i
-        expect(event["tags"]).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
-        expect(event[LogStash::Event::TIMESTAMP_FAILURE_FIELD]).to eq(666)
-      end
-
-      it "should warn for invalid value" do
-        LogStash::Event.logger = logger_mock
-
-        expect(logger_mock).to receive(:warn).twice
-
-        LogStash::Event.new("@timestamp" => :foo)
-        LogStash::Event.new("@timestamp" => 666)
-      end
-
-      it "should tag for invalid string format" do
-        event = LogStash::Event.new("@timestamp" => "foo")
-        expect(event.timestamp.to_i).to be_within(1).of Time.now.to_i
-        expect(event["tags"]).to eq([LogStash::Event::TIMESTAMP_FAILURE_TAG])
-        expect(event[LogStash::Event::TIMESTAMP_FAILURE_FIELD]).to eq("foo")
-      end
-
-      it "should warn for invalid string format" do
-        LogStash::Event.logger = logger_mock
-
-        expect(logger_mock).to receive(:warn)
-        LogStash::Event.new("@timestamp" => "foo")
-      end
-    end
-
-    context "to_json" do
-      it "should support to_json" do
-        new_event = LogStash::Event.new(
-          "@timestamp" => Time.iso8601("2014-09-23T19:26:15.832Z"),
-          "message" => "foo bar",
-        )
-        json = new_event.to_json
-
-        expect(JSON.parse(json)).to eq( JSON.parse("{\"@timestamp\":\"2014-09-23T19:26:15.832Z\",\"message\":\"foo bar\",\"@version\":\"1\"}"))
-      end
-
-      it "should support to_json and ignore arguments" do
-        new_event = LogStash::Event.new(
-          "@timestamp" => Time.iso8601("2014-09-23T19:26:15.832Z"),
-          "message" => "foo bar",
-        )
-        json = new_event.to_json(:foo => 1, :bar => "baz")
-
-        expect(JSON.parse(json)).to eq( JSON.parse("{\"@timestamp\":\"2014-09-23T19:26:15.832Z\",\"message\":\"foo bar\",\"@version\":\"1\"}"))
-      end
-    end
-
-    context "metadata" do
-      context "with existing metadata" do
-        subject { LogStash::Event.new("hello" => "world", "@metadata" => { "fancy" => "pants" }) }
-
-        it "should not include metadata in to_hash" do
-          expect(subject.to_hash.keys).not_to include("@metadata")
-
-          # 'hello', '@timestamp', and '@version'
-          expect(subject.to_hash.keys.count).to eq(3)
-        end
-
-        it "should still allow normal field access" do
-          expect(subject["hello"]).to eq("world")
-        end
-      end
-
-      context "with set metadata" do
-        let(:fieldref) { "[@metadata][foo][bar]" }
-        let(:value) { "bar" }
-        subject { LogStash::Event.new("normal" => "normal") }
-        before do
-          # Verify the test is configured correctly.
-          expect(fieldref).to start_with("[@metadata]")
-
-          # Set it.
-          subject[fieldref] = value
-        end
-
-        it "should still allow normal field access" do
-          expect(subject["normal"]).to eq("normal")
-        end
-
-        it "should allow getting" do
-          expect(subject[fieldref]).to eq(value)
-        end
-
-        it "should be hidden from .to_json" do
-          require "json"
-          obj = JSON.parse(subject.to_json)
-          expect(obj).not_to include("@metadata")
-        end
-
-        it "should be hidden from .to_hash" do
-          expect(subject.to_hash).not_to include("@metadata")
-        end
-
-        it "should be accessible through #to_hash_with_metadata" do
-          obj = subject.to_hash_with_metadata
-          expect(obj).to include("@metadata")
-          expect(obj["@metadata"]["foo"]["bar"]).to eq(value)
-        end
-      end
-
-      context "with no metadata" do
-        subject { LogStash::Event.new("foo" => "bar") }
-        it "should have no metadata" do
-          expect(subject["@metadata"]).to be_empty
-        end
-        it "should still allow normal field access" do
-          expect(subject["foo"]).to eq("bar")
-        end
-
-        it "should not include the @metadata key" do
-          expect(subject.to_hash_with_metadata).not_to include("@metadata")
-        end
-      end
-    end
-
-    context "signal events" do
-      it "should define the shutdown event" do
-        # the SHUTDOWN and FLUSH constants are part of the plugin API contract
-        # if they are changed, all plugins must be updated
-        expect(LogStash::SHUTDOWN).to be_a(LogStash::ShutdownEvent)
-        expect(LogStash::FLUSH).to be_a(LogStash::FlushEvent)
-      end
-    end
-  end
-
-  let(:event_hash) do
-    {
-      "@timestamp" => "2013-01-01T00:00:00.000Z",
-      "type" => "sprintf",
-      "message" => "hello world",
-      "tags" => [ "tag1" ],
-      "source" => "/home/foo",
-      "a" => "b",
-      "c" => {
-        "d" => "f",
-        "e" => {"f" => "g"}
-      },
-      "f" => { "g" => { "h" => "i" } },
-      "j" => {
-          "k1" => "v",
-          "k2" => [ "w", "x" ],
-          "k3" => {"4" => "m"},
-          "k4" => [ {"nested" => "cool"} ],
-          5 => 6,
-          "5" => 7
-      },
-      "nilfield" => nil,
-      "@metadata" => { "fancy" => "pants", "have-to-go" => { "deeper" => "inception" } }
-    }
-  end
-
-  describe "using normal hash input" do
-    it_behaves_like "all event tests" do
-      subject{LogStash::Event.new(event_hash)}
-    end
-  end
-
-  describe "using hash input from deserialized json" do
-    # this is to test the case when JrJackson deserialises Json and produces
-    # native Java Collections objects for efficiency
-    it_behaves_like "all event tests" do
-      subject{LogStash::Event.new(LogStash::Json.load(LogStash::Json.dump(event_hash)))}
-    end
-  end
-
-
-  describe "#to_s" do
-    let(:timestamp) { LogStash::Timestamp.new }
-    let(:event1) { LogStash::Event.new({ "@timestamp" => timestamp, "host" => "foo", "message" => "bar"}) }
-    let(:event2) { LogStash::Event.new({ "host" => "bar", "message" => "foo"}) }
-
-    it "should cache only one template" do
-      LogStash::StringInterpolation.clear_cache
-      expect {
-        event1.to_s
-        event2.to_s
-      }.to change { LogStash::StringInterpolation.cache_size }.by(1)
-    end
-
-    it "return the string containing the timestamp, the host and the message" do
-      expect(event1.to_s).to eq("#{timestamp.to_iso8601} #{event1["host"]} #{event1["message"]}")
-    end
-  end
-
-  describe "Event accessors" do
-    let(:event) { LogStash::Event.new({ "message" => "foo" }) }
-
-    it "should invalidate target caching" do
-      expect(event["[a][0]"]).to be_nil
-
-      expect(event["[a][0]"] = 42).to eq(42)
-      expect(event["[a][0]"]).to eq(42)
-      expect(event["[a]"]).to eq({"0" => 42})
-
-      expect(event["[a]"] = [42, 24]).to eq([42, 24])
-      expect(event["[a]"]).to eq([42, 24])
-
-      expect(event["[a][0]"]).to eq(42)
-
-      expect(event["[a]"] = [24, 42]).to eq([24, 42])
-      expect(event["[a][0]"]).to eq(24)
-
-      expect(event["[a][0]"] = {"a "=> 99, "b" => 98}).to eq({"a "=> 99, "b" => 98})
-      expect(event["[a][0]"]).to eq({"a "=> 99, "b" => 98})
-
-      expect(event["[a]"]).to eq([{"a "=> 99, "b" => 98}, 42])
-      expect(event["[a][0]"]).to eq({"a "=> 99, "b" => 98})
-      expect(event["[a][1]"]).to eq(42)
-      expect(event["[a][0][b]"]).to eq(98)
-    end
-  end
-end
-