logstash-core-event-java 5.0.0.alpha2.snapshot2-java → 5.0.0.alpha3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc35efdbdd5b5b925626d1e40c15b354303fdc00
-  data.tar.gz: cbfefdca225a3691554bc6aeba75955d80888cb8
+  metadata.gz: 26d37f5eb21593563b589a05bc7601a8079b6ec3
+  data.tar.gz: 75e52a1e593eb8cd9088866c335fadb0d5525faa
 SHA512:
-  metadata.gz: 0dcc25cb787a792ceabb0f07631e8ddd38981cd1134b09c9d2a7b5227311bbd52fa4959a067499d9ee515b345c77d6c396fd881bf599cfe5b16d88c6a7859bec
-  data.tar.gz: 93117d0d647f39fcb061d8669dfd78471b05461b8d27973ba7491dd8a94fde425182c97d536e668f0f52950d480052cb641fee3af87a09f6528e74d0ec2406f4
+  metadata.gz: ab1ede5872c47938f652dfea356469ad1bf41a220972a7c668ce3af2dae23f6e23e2bb53d120a2afbd4367943761ee9743a96a080b6ae393b4a9aecdd58762d2
+  data.tar.gz: 514700d367b3da6bd59caa7eda9950404a32ecf347bca2c729fb895f9c1e82a40fc70df9a85c284fe6b6a520a11d4480b027975c3a29caa6fc43aebded120e89

data/lib/logstash-core-event-java/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_JAVA_VERSION = "5.0.0-alpha2.snapshot2"
+LOGSTASH_CORE_EVENT_JAVA_VERSION = "5.0.0-alpha3"

data/spec/event_spec.rb

@@ -4,6 +4,7 @@ require "spec_helper"
 require "logstash/util"
 require "logstash/event"
 require "json"
+require "java"
 
 TIMESTAMP = "@timestamp"
 
@@ -26,10 +27,10 @@ describe LogStash::Event do
 
     it "should serialize deep hash from field reference assignments" do
       e = LogStash::Event.new({TIMESTAMP => "2015-05-28T23:02:05.350Z"})
-      e["foo"] = "bar"
-      e["bar"] = 1
-      e["baz"] = 1.0
-      e["[fancy][pants][socks]"] = "shoes"
+      e.set("foo", "bar")
+      e.set("bar", 1)
+      e.set("baz", 1.0)
+      e.set("[fancy][pants][socks]", "shoes")
       expect(JSON.parse(e.to_json)).to eq(JSON.parse("{\"@timestamp\":\"2015-05-28T23:02:05.350Z\",\"@version\":\"1\",\"foo\":\"bar\",\"bar\":1,\"baz\":1.0,\"fancy\":{\"pants\":{\"socks\":\"shoes\"}}}"))
     end
   end
@@ -37,79 +38,79 @@ describe LogStash::Event do
   context "[]" do
     it "should get simple values" do
       e = LogStash::Event.new({"foo" => "bar", "bar" => 1, "baz" => 1.0, TIMESTAMP => "2015-05-28T23:02:05.350Z"})
-      expect(e["foo"]).to eq("bar")
-      expect(e["[foo]"]).to eq("bar")
-      expect(e["bar"]).to eq(1)
-      expect(e["[bar]"]).to eq(1)
-      expect(e["baz"]).to eq(1.0)
-      expect(e["[baz]"]).to eq(1.0)
-      expect(e[TIMESTAMP].to_s).to eq("2015-05-28T23:02:05.350Z")
-      expect(e["[#{TIMESTAMP}]"].to_s).to eq("2015-05-28T23:02:05.350Z")
+      expect(e.get("foo")).to eq("bar")
+      expect(e.get("[foo]")).to eq("bar")
+      expect(e.get("bar")).to eq(1)
+      expect(e.get("[bar]")).to eq(1)
+      expect(e.get("baz")).to eq(1.0)
+      expect(e.get("[baz]")).to eq(1.0)
+      expect(e.get(TIMESTAMP).to_s).to eq("2015-05-28T23:02:05.350Z")
+      expect(e.get("[#{TIMESTAMP}]").to_s).to eq("2015-05-28T23:02:05.350Z")
     end
 
     it "should get deep hash values" do
       e = LogStash::Event.new({"foo" => {"bar" => 1, "baz" => 1.0}})
-      expect(e["[foo][bar]"]).to eq(1)
-      expect(e["[foo][baz]"]).to eq(1.0)
+      expect(e.get("[foo][bar]")).to eq(1)
+      expect(e.get("[foo][baz]")).to eq(1.0)
     end
 
     it "should get deep array values" do
       e = LogStash::Event.new({"foo" => ["bar", 1, 1.0]})
-      expect(e["[foo][0]"]).to eq("bar")
-      expect(e["[foo][1]"]).to eq(1)
-      expect(e["[foo][2]"]).to eq(1.0)
-      expect(e["[foo][3]"]).to be_nil
+      expect(e.get("[foo][0]")).to eq("bar")
+      expect(e.get("[foo][1]")).to eq(1)
+      expect(e.get("[foo][2]")).to eq(1.0)
+      expect(e.get("[foo][3]")).to be_nil
     end
   end
 
   context "[]=" do
     it "should set simple values" do
       e = LogStash::Event.new()
-      expect(e["foo"] = "bar").to eq("bar")
-      expect(e["foo"]).to eq("bar")
+      expect(e.set("foo", "bar")).to eq("bar")
+      expect(e.get("foo")).to eq("bar")
 
       e = LogStash::Event.new({"foo" => "test"})
-      expect(e["foo"] = "bar").to eq("bar")
-      expect(e["foo"]).to eq("bar")
+      expect(e.set("foo", "bar")).to eq("bar")
+      expect(e.get("foo")).to eq("bar")
     end
 
     it "should set deep hash values" do
       e = LogStash::Event.new()
-      expect(e["[foo][bar]"] = "baz").to eq("baz")
-      expect(e["[foo][bar]"]).to eq("baz")
-      expect(e["[foo][baz]"]).to be_nil
+      expect(e.set("[foo][bar]", "baz")).to eq("baz")
+      expect(e.get("[foo][bar]")).to eq("baz")
+      expect(e.get("[foo][baz]")).to be_nil
     end
 
     it "should set deep array values" do
       e = LogStash::Event.new()
-      expect(e["[foo][0]"] = "bar").to eq("bar")
-      expect(e["[foo][0]"]).to eq("bar")
-      expect(e["[foo][1]"] = 1).to eq(1)
-      expect(e["[foo][1]"]).to eq(1)
-      expect(e["[foo][2]"] = 1.0 ).to eq(1.0)
-      expect(e["[foo][2]"]).to eq(1.0)
-      expect(e["[foo][3]"]).to be_nil
+      expect(e.set("[foo][0]", "bar")).to eq("bar")
+      expect(e.get("[foo][0]")).to eq("bar")
+      expect(e.set("[foo][1]", 1)).to eq(1)
+      expect(e.get("[foo][1]")).to eq(1)
+      expect(e.set("[foo][2]", 1.0)).to eq(1.0)
+      expect(e.get("[foo][2]")).to eq(1.0)
+      expect(e.get("[foo][3]")).to be_nil
     end
 
     it "should add key when setting nil value" do
       e = LogStash::Event.new()
-      e["[foo]"] = nil
+      e.set("[foo]", nil)
       expect(e.to_hash).to include("foo" => nil)
     end
 
     # BigDecinal is now natively converted by JRuby, see https://github.com/elastic/logstash/pull/4838
     it "should set BigDecimal" do
       e = LogStash::Event.new()
-      e["[foo]"] = BigDecimal.new(1)
-      expect(e["foo"]).to be_kind_of(BigDecimal)
-      expect(e["foo"]).to eq(BigDecimal.new(1))
+      e.set("[foo]", BigDecimal.new(1))
+      expect(e.get("foo")).to be_kind_of(BigDecimal)
+      expect(e.get("foo")).to eq(BigDecimal.new(1))
     end
 
     it "should set RubyBignum" do
       e = LogStash::Event.new()
-      e["[foo]"] = -9223372036854776000
-      expect(e["foo"]).to be_kind_of(Bignum)
-      expect(e["foo"]).to eq(-9223372036854776000)
+      e.set("[foo]", -9223372036854776000)
+      expect(e.get("foo")).to be_kind_of(Bignum)
+      expect(e.get("foo")).to eq(-9223372036854776000)
     end
   end
 
@@ -117,7 +118,7 @@ describe LogStash::Event do
     it "getters should present a Ruby LogStash::Timestamp" do
       e = LogStash::Event.new()
       expect(e.timestamp.class).to eq(LogStash::Timestamp)
-      expect(e[TIMESTAMP].class).to eq(LogStash::Timestamp)
+      expect(e.get(TIMESTAMP).class).to eq(LogStash::Timestamp)
     end
 
     it "to_hash should inject a Ruby LogStash::Timestamp" do
@@ -134,9 +135,9 @@ describe LogStash::Event do
     it "should set timestamp" do
       e = LogStash::Event.new
       now = Time.now
-      e["@timestamp"] = LogStash::Timestamp.at(now.to_i)
+      e.set("@timestamp", LogStash::Timestamp.at(now.to_i))
       expect(e.timestamp.to_i).to eq(now.to_i)
-      expect(e["@timestamp"].to_i).to eq(now.to_i)
+      expect(e.get("@timestamp").to_i).to eq(now.to_i)
     end
   end
 
@@ -144,16 +145,16 @@ describe LogStash::Event do
     it "should append" do
       event = LogStash::Event.new("message" => "hello world")
       event.append(LogStash::Event.new("message" => "another thing"))
-      expect(event["message"]).to eq(["hello world", "another thing"])
+      expect(event.get("message")).to eq(["hello world", "another thing"])
     end
   end
 
   context "tags" do
     it "should tag" do
       event = LogStash::Event.new("message" => "hello world")
-      expect(event["tags"]).to be_nil
-      event["tags"] = ["foo"]
-      expect(event["tags"]).to eq(["foo"])
+      expect(event.get("tags")).to be_nil
+      event.tag("foo")
+      expect(event.get("tags")).to eq(["foo"])
     end
   end
 
@@ -258,8 +259,8 @@ describe LogStash::Event do
       expect(LogStash::Event.from_json(source_json).size).to eq(1)
 
       event = LogStash::Event.from_json(source_json)[0]
-      expect(event["[foo]"]).to eq(1)
-      expect(event["[bar]"]).to eq("baz")
+      expect(event.get("[foo]")).to eq(1)
+      expect(event.get("[bar]")).to eq("baz")
     end
 
     it "should ignore blank strings" do
@@ -286,4 +287,24 @@ describe LogStash::Event do
        end
     end
   end
+
+  context "initialize" do
+
+    it "should accept Ruby Hash" do
+      e = LogStash::Event.new({"foo" => 1, TIMESTAMP => "2015-05-28T23:02:05.350Z"})
+      expect(e.get("foo")).to eq(1)
+      expect(e.timestamp.to_iso8601).to eq("2015-05-28T23:02:05.350Z")
+    end
+
+    it "should accept Java Map" do
+      h = Java::JavaUtil::HashMap.new
+      h.put("foo", 2);
+      h.put(TIMESTAMP, "2016-05-28T23:02:05.350Z");
+      e = LogStash::Event.new(h)
+
+      expect(e.get("foo")).to eq(2)
+      expect(e.timestamp.to_iso8601).to eq("2016-05-28T23:02:05.350Z")
+    end
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-core-event-java
 version: !ruby/object:Gem::Version
-  version: 5.0.0.alpha2.snapshot2
+  version: 5.0.0.alpha3
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-04-28 00:00:00.000000000 Z
+date: 2016-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement