logstash-core-event-java 2.3.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b8b4e8b94ae05ed8f2eb1af7bd990be9acf5322
+  data.tar.gz: cef8c61a58927d1907d798da7732d4e1288645c4
+SHA512:
+  metadata.gz: 2f16f37d45723ffd2297634a285a2b0f7213daa7361df2f5e321d770b81f70f45e3e10c67ba657fe390ffda04bec247a470b8746706b074457653848d1bb316c
+  data.tar.gz: 454ce13338a43a136f53596f498e18d7a154e5b59e8733346d7e4b3a5fdceef5e6068017ba6e428f96794fb2a486b2250983a2f13c7be7ecb640333f56b128f0

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

@@ -0,0 +1 @@
+require "logstash-core-event-java/logstash-core-event-java"

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require "java"
+
+module LogStash
+end
+
+require "logstash-core-event-java_jars"
+
+# local dev setup
+classes_dir = File.expand_path("../../../build/classes/main", __FILE__)
+
+if File.directory?(classes_dir)
+  # if in local dev setup, add target to classpath
+  $CLASSPATH << classes_dir unless $CLASSPATH.include?(classes_dir)
+else
+  # otherwise use included jar
+  begin
+    require "logstash-core-event-java/logstash-core-event-java.jar"
+  rescue Exception => e
+    raise("Error loading logstash-core-event-java/logstash-core-event-java.jar file, cause: #{e.message}")
+  end
+end
+
+require "jruby_event_ext"
+require "jruby_timestamp_ext"
+require "logstash/event"
+require "logstash/timestamp"

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

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# The version of logstash core event java gem.
+#
+# 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 = "2.3.0"

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

@@ -0,0 +1,6 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+require 'jar_dependencies'
+
+require_jar( 'com.fasterxml.jackson.core', 'jackson-core', '2.7.1' )
+require_jar( 'com.fasterxml.jackson.core', 'jackson-annotations', '2.7.0' )
+require_jar( 'com.fasterxml.jackson.core', 'jackson-databind', '2.7.1-1' )

data/lib/logstash-core-event.rb

@@ -0,0 +1 @@
+require "logstash-core-event-java/logstash-core-event-java"

data/lib/logstash/event.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require "logstash/namespace"
+require "logstash/json"
+require "logstash/string_interpolation"
+require "cabin"
+
+# transcient pipeline events for normal in-flow signaling as opposed to
+# flow altering exceptions. for now having base classes is adequate and
+# in the future it might be necessary to refactor using like a BaseEvent
+# class to have a common interface for all pileline events to support
+# eventual queueing persistence for example, TBD.
+class LogStash::ShutdownEvent; end
+class LogStash::FlushEvent; end
+
+module LogStash
+  FLUSH = LogStash::FlushEvent.new
+
+  # LogStash::SHUTDOWN is used by plugins
+  SHUTDOWN = LogStash::ShutdownEvent.new
+end
+
+# for backward compatibility, require "logstash/event" is used a lots of places so let's bootstrap the
+# Java code loading from here.
+# TODO: (colin) I think we should mass replace require "logstash/event" with require "logstash-core-event"
+require "logstash-core-event"

data/lib/logstash/string_interpolation.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module LogStash
+  module StringInterpolation
+    extend self
+
+    # clear the global compiled templates cache
+    def clear_cache
+      Java::ComLogstash::StringInterpolation.get_instance.clear_cache;
+    end
+
+    # @return [Fixnum] the compiled templates cache size
+    def cache_size
+      Java::ComLogstash::StringInterpolation.get_instance.cache_size;
+    end
+  end
+end
+

data/lib/logstash/timestamp.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require "logstash/namespace"
+require "logstash-core-event"
+
+module LogStash
+  class TimestampParserError < StandardError; end
+
+  class Timestamp
+    include Comparable
+
+    # TODO (colin) implement in Java
+    def <=>(other)
+      self.time <=> other.time
+    end
+
+    # TODO (colin) implement in Java
+    def +(other)
+      self.time + other
+    end
+
+    # TODO (colin) implement in Java
+    def -(value)
+      self.time - (value.is_a?(Timestamp) ? value.time : value)
+    end
+
+  end
+end

data/logstash-core-event-java.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'logstash-core-event-java/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Elastic"]
+  gem.email         = ["info@elastic.co"]
+  gem.description   = %q{The core event component of logstash, the scalable log and event management tool}
+  gem.summary       = %q{logstash-core-event-java - The core event component of logstash}
+  gem.homepage      = "http://www.elastic.co/guide/en/logstash/current/index.html"
+  gem.license       = "Apache License (2.0)"
+
+  gem.files         = Dir.glob(["logstash-core-event-java.gemspec", "lib/**/*.jar", "lib/**/*.rb", "spec/**/*.rb"])
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "logstash-core-event-java"
+  gem.require_paths = ["lib"]
+  gem.version       = LOGSTASH_CORE_EVENT_JAVA_VERSION
+
+  gem.platform = "java"
+
+  gem.add_runtime_dependency "jar-dependencies"
+
+  # as of Feb 3rd 2016, the ruby-maven gem is resolved to version 3.3.3 and that version
+  # has an rdoc problem that causes a bundler exception. 3.3.9 is the current latest version
+  # which does not have this problem.
+  gem.add_runtime_dependency "ruby-maven", "~> 3.3.9"
+
+  gem.requirements << "jar com.fasterxml.jackson.core:jackson-core, 2.7.1"
+  gem.requirements << "jar com.fasterxml.jackson.core:jackson-databind, 2.7.1-1"
+end

data/spec/event_spec.rb

@@ -0,0 +1,289 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "logstash/util"
+require "logstash/event"
+require "json"
+
+TIMESTAMP = "@timestamp"
+
+describe LogStash::Event do
+  context "to_json" do
+    it "should serialize simple values" do
+      e = LogStash::Event.new({"foo" => "bar", "bar" => 1, "baz" => 1.0, TIMESTAMP => "2015-05-28T23:02:05.350Z"})
+      expect(JSON.parse(e.to_json)).to eq(JSON.parse("{\"foo\":\"bar\",\"bar\":1,\"baz\":1.0,\"@timestamp\":\"2015-05-28T23:02:05.350Z\",\"@version\":\"1\"}"))
+    end
+
+    it "should serialize deep hash values" do
+      e = LogStash::Event.new({"foo" => {"bar" => 1, "baz" => 1.0, "biz" => "boz"}, TIMESTAMP => "2015-05-28T23:02:05.350Z"})
+      expect(JSON.parse(e.to_json)).to eq(JSON.parse("{\"foo\":{\"bar\":1,\"baz\":1.0,\"biz\":\"boz\"},\"@timestamp\":\"2015-05-28T23:02:05.350Z\",\"@version\":\"1\"}"))
+    end
+
+    it "should serialize deep array values" do
+      e = LogStash::Event.new({"foo" => ["bar", 1, 1.0], TIMESTAMP => "2015-05-28T23:02:05.350Z"})
+      expect(JSON.parse(e.to_json)).to eq(JSON.parse("{\"foo\":[\"bar\",1,1.0],\"@timestamp\":\"2015-05-28T23:02:05.350Z\",\"@version\":\"1\"}"))
+    end
+
+    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"
+      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
+
+  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")
+    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)
+    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
+    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")
+
+      e = LogStash::Event.new({"foo" => "test"})
+      expect(e["foo"] = "bar").to eq("bar")
+      expect(e["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
+    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
+    end
+
+    it "should add key when setting nil value" do
+      e = LogStash::Event.new()
+      e["[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))
+    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)
+    end
+  end
+
+  context "timestamp" 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)
+    end
+
+    it "to_hash should inject a Ruby LogStash::Timestamp" do
+      e = LogStash::Event.new()
+
+      expect(e.to_java).to be_kind_of(Java::ComLogstash::Event)
+      expect(e.to_java.get_field(TIMESTAMP)).to be_kind_of(Java::ComLogstash::Timestamp)
+
+      expect(e.to_hash[TIMESTAMP]).to be_kind_of(LogStash::Timestamp)
+      # now make sure the original map was not touched
+      expect(e.to_java.get_field(TIMESTAMP)).to be_kind_of(Java::ComLogstash::Timestamp)
+    end
+
+    it "should set timestamp" do
+      e = LogStash::Event.new
+      now = Time.now
+      e["@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)
+    end
+  end
+
+  context "append" 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"])
+    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"])
+    end
+  end
+
+
+  # noop logger used to test the injectable logger in Event
+  # this implementation is not complete because only the warn
+  # method is used in Event.
+  module DummyLogger
+    def self.warn(message)
+      # do nothing
+    end
+  end
+
+  context "logger" do
+
+    let(:logger) { double("Logger") }
+    after(:each) {  LogStash::Event.logger = LogStash::Event::DEFAULT_LOGGER }
+
+    # the following 2 specs are using both a real module (DummyLogger)
+    # and a mock. both tests are needed to make sure the implementation
+    # supports both types of objects.
+
+    it "should set logger using a module" do
+      LogStash::Event.logger = DummyLogger
+      expect(DummyLogger).to receive(:warn).once
+      LogStash::Event.new(TIMESTAMP => "invalid timestamp")
+    end
+
+    it "should set logger using a mock" do
+      LogStash::Event.logger = logger
+      expect(logger).to receive(:warn).once
+      LogStash::Event.new(TIMESTAMP => "invalid timestamp")
+    end
+
+    it "should unset logger" do
+      # first set
+      LogStash::Event.logger = logger
+      expect(logger).to receive(:warn).once
+      LogStash::Event.new(TIMESTAMP => "invalid timestamp")
+
+      # then unset
+      LogStash::Event.logger = LogStash::Event::DEFAULT_LOGGER
+      expect(logger).to receive(:warn).never
+      # this will produce a log line in stdout by the Java Event
+      LogStash::Event.new(TIMESTAMP => "ignore this log")
+    end
+
+
+    it "should warn on parsing error" do
+      LogStash::Event.logger = logger
+      expect(logger).to receive(:warn).once.with(/^Error parsing/)
+      LogStash::Event.new(TIMESTAMP => "invalid timestamp")
+    end
+
+    it "should warn on invalid timestamp object" do
+      LogStash::Event.logger = logger
+      expect(logger).to receive(:warn).once.with(/^Unrecognized/)
+      LogStash::Event.new(TIMESTAMP => Array.new)
+    end
+  end
+
+  context "to_hash" do
+    let (:source_hash) {  {"a" => 1, "b" => [1, 2, 3, {"h" => 1, "i" => "baz"}], "c" => {"d" => "foo", "e" => "bar", "f" => [4, 5, "six"]}} }
+    let (:source_hash_with_matada) {  source_hash.merge({"@metadata" => {"a" => 1, "b" => 2}}) }
+    subject { LogStash::Event.new(source_hash_with_matada) }
+
+    it "should include @timestamp and @version" do
+      h = subject.to_hash
+      expect(h).to include("@timestamp")
+      expect(h).to include("@version")
+      expect(h).not_to include("@metadata")
+    end
+
+    it "should include @timestamp and @version and @metadata" do
+      h = subject.to_hash_with_metadata
+      expect(h).to include("@timestamp")
+      expect(h).to include("@version")
+      expect(h).to include("@metadata")
+    end
+
+    it "should produce valid deep Ruby hash without metadata" do
+      h = subject.to_hash
+      h.delete("@timestamp")
+      h.delete("@version")
+      expect(h).to eq(source_hash)
+    end
+
+    it "should produce valid deep Ruby hash with metadata" do
+      h = subject.to_hash_with_metadata
+      h.delete("@timestamp")
+      h.delete("@version")
+      expect(h).to eq(source_hash_with_matada)
+    end
+  end
+
+  context "from_json" do
+    let (:source_json) { "{\"foo\":1, \"bar\":\"baz\"}" }
+    let (:blank_strings) {["", "  ",  "   "]}
+    let (:bare_strings) {["aa", "  aa", "aa  "]}
+
+    it "should produce a new event from json" 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")
+    end
+
+    it "should ignore blank strings" do
+      blank_strings.each do |s|
+        expect(LogStash::Event.from_json(s).size).to eq(0)
+      end
+    end
+
+    it "should raise TypeError on nil string" do
+      expect{LogStash::Event.from_json(nil)}.to raise_error TypeError
+    end
+
+    it "should consistently handle nil" do
+      blank_strings.each do |s|
+        expect{LogStash::Event.from_json(nil)}.to raise_error
+        expect{LogStash::Event.new(LogStash::Json.load(nil))}.to raise_error
+      end
+    end
+
+    it "should consistently handle bare string" do
+      bare_strings.each do |s|
+        expect{LogStash::Event.from_json(s)}.to raise_error LogStash::Json::ParserError
+        expect{LogStash::Event.new(LogStash::Json.load(s))}.to raise_error LogStash::Json::ParserError
+       end
+    end
+  end
+end

data/spec/timestamp_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "logstash/timestamp"
+
+describe LogStash::Timestamp do
+  context "constructors" do
+    it "should work" do
+      t = LogStash::Timestamp.new
+      expect(t.time.to_i).to be_within(1).of Time.now.to_i
+
+      t = LogStash::Timestamp.now
+      expect(t.time.to_i).to be_within(1).of Time.now.to_i
+
+      now = Time.now.utc
+      t = LogStash::Timestamp.new(now)
+      expect(t.time).to eq(now)
+
+      t = LogStash::Timestamp.at(now.to_i)
+      expect(t.time.to_i).to eq(now.to_i)
+    end
+
+    it "should raise exception on invalid format" do
+      expect{LogStash::Timestamp.new("foobar")}.to raise_error
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: logstash-core-event-java
+version: !ruby/object:Gem::Version
+  version: 2.3.0
+platform: java
+authors:
+- Elastic
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: jar-dependencies
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.9
+  name: ruby-maven
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.9
+description: The core event component of logstash, the scalable log and event management tool
+email:
+- info@elastic.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/com/fasterxml/jackson/core/jackson-annotations/2.7.0/jackson-annotations-2.7.0.jar
+- lib/com/fasterxml/jackson/core/jackson-core/2.7.1/jackson-core-2.7.1.jar
+- lib/com/fasterxml/jackson/core/jackson-databind/2.7.1-1/jackson-databind-2.7.1-1.jar
+- lib/logstash-core-event-java.rb
+- lib/logstash-core-event-java/logstash-core-event-java.jar
+- lib/logstash-core-event-java/logstash-core-event-java.rb
+- lib/logstash-core-event-java/version.rb
+- lib/logstash-core-event-java_jars.rb
+- lib/logstash-core-event.rb
+- lib/logstash/event.rb
+- lib/logstash/string_interpolation.rb
+- lib/logstash/timestamp.rb
+- lib/org/codehaus/jackson/jackson-core-asl/1.9.13/jackson-core-asl-1.9.13.jar
+- lib/org/codehaus/jackson/jackson-mapper-asl/1.9.13/jackson-mapper-asl-1.9.13.jar
+- logstash-core-event-java.gemspec
+- spec/event_spec.rb
+- spec/timestamp_spec.rb
+homepage: http://www.elastic.co/guide/en/logstash/current/index.html
+licenses:
+- Apache License (2.0)
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- jar com.fasterxml.jackson.core:jackson-core, 2.7.1
+- jar com.fasterxml.jackson.core:jackson-databind, 2.7.1-1
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: logstash-core-event-java - The core event component of logstash
+test_files:
+- spec/event_spec.rb
+- spec/timestamp_spec.rb