logstash-input-jmx 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67673b34c4e945d059fcaa7e33a03ca2070b1bba
-  data.tar.gz: 7f2d0ad1b534e028be342a40576e051fd5d5b55d
+  metadata.gz: 7086a6d48c28232b76bc569a275c3bb32a09c08e
+  data.tar.gz: b84125c9b177064bc94aa5b1379089fd3c931296
 SHA512:
-  metadata.gz: 1880ae440dbc2769ac3f56a00cea10c256740992663ca0ef86050a715e5ed5838cf29571b0ba576383a1b8292f5a31b674f7a54ca76fc9c259e6de85756c566d
-  data.tar.gz: 1680bf84de7847953ad9d98aab0144b60c37b1be82058680c0e045236c96e7ee25b16288320f8e81471668ca7e42582581f61b641d29ef451130118d4ffd497e
+  metadata.gz: db45a1f480c834c8b1d12e2648cf61b9d33eb6670abd356d966adf4406a7db7f1190a9b2d7098adfad75046d2fdd0961c07d6fad3ca128840228677739007f5a
+  data.tar.gz: b0d578838b8d9da72a0e6fe3e5e3c1815ee7faa4d2952688a217878f9e98dfddffd2fbf6e7115fa39baad7518caf0aee6d5ac55b86aeab9b906d7202fd7d1242

data/lib/logstash/inputs/jmx.rb

@@ -106,73 +106,55 @@ class LogStash::Inputs::Jmx < LogStash::Inputs::Base
   # Indicate number of thread launched to retrieve metrics
   config :nb_thread, :validate => :number, :default => 4
 
-  # Read and parse json conf
-  private
-  def read_conf(file_conf)
-    @logger.debug("Parse json #{file_conf} to ruby data structure")
-    json = File.read(file_conf)
-    LogStash::Json.load(json)
-  end
-
+  #Error messages
+  MISSING_CONFIG_PARAMETER = "Missing parameter '%s'."
+  BAD_TYPE_CONFIG_PARAMETER = "Bad type for parameter '%{param}', expecting '%{expected}', found '%{actual}'."
+  MISSING_QUERY_PARAMETER = "Missing parameter '%s' in queries[%d]."
+  BAD_TYPE_QUERY = "Bad type for queries[%{index}], expecting '%{expected}', found '%{actual}'."
+  BAD_TYPE_QUERY_PARAMETER = "Bad type for parameter '%{param}' in queries[%{index}], expecting '%{expected}', found '%{actual}'."
   # Verify that all required parameter are present in the conf_hash
-  private
-  def check_conf(conf_hash,file_conf)
-    #Check required parameters
-    @logger.debug("Check that required parameters are define with good types in #{conf_hash}")
-    parameter = {'host' => 'String'.class, 'port' => 1.class, 'queries' => [].class}
-    parameter.each_key do |param|
-      if conf_hash.has_key?(param)
-        unless conf_hash[param].instance_of?(parameter[param])
-          @logger.error("Bad syntax for conf file #{file_conf}. Bad types for parameter #{param}, expecting #{parameter[param]}, found #{conf_hash[param].class}.")
-          return false
-        end
-      else
-        @logger.error("Bad syntax for conf file #{file_conf}. Missing parameter #{param}.")
-        return false
-      end
+  public
+  def validate_configuration(conf_hash)
+    validation_errors = []
+    #Check required parameters in configuration
+    ["host", "port","queries"].each do |param|
+      validation_errors << MISSING_CONFIG_PARAMETER % param unless conf_hash.has_key?(param)
     end
 
-    @logger.debug('Check optional parameters types')
-    parameter = {'alias' => 'String'.class}
-    parameter.each_key do |param|
-      if conf_hash.has_key?(param)
-        unless conf_hash[param].instance_of?(parameter[param])
-          @logger.error("Bad syntax for conf file #{file_conf}. Bad types for parameter #{param}, expecting #{parameter[param]}, found #{conf_hash[param].class}.")
-          return false
-        end
+    #Validate parameters type in configuration
+    {"host" => String, "port" => Fixnum, "alias" => String }.each do |param, expected_type|
+      if conf_hash.has_key?(param) && !conf_hash[param].instance_of?(expected_type)
+        validation_errors << BAD_TYPE_CONFIG_PARAMETER % { :param => param, :expected => expected_type, :actual => conf_hash[param].class }
       end
     end
 
-    @logger.debug('Check that required parameters are define with good types for queries')
-    parameter = {'object_name' => 'String'.class}
-    parameter.each_key do |param|
-      conf_hash['queries'].each do |query|
-        if query.has_key?(param)
-          unless query[param].instance_of?(parameter[param])
-            @logger.error("Bad syntax for conf file #{file_conf}. Bad types for parameter #{param} in query #{query}, expecting #{parameter[param]}, found #{conf_hash[param].class}.")
-            return false
+    if conf_hash.has_key?("queries")
+      if !conf_hash["queries"].respond_to?(:each)
+        validation_errors << BAD_TYPE_CONFIG_PARAMETER % { :param => 'queries', :expected => Enumerable, :actual => conf_hash['queries'].class }
+      else
+        conf_hash['queries'].each_with_index do |query,index|
+          unless query.respond_to?(:[]) && query.respond_to?(:has_key?)
+            validation_errors << BAD_TYPE_QUERY % {:index => index, :expected => Hash, :actual => query.class}
+            next
+          end
+          #Check required parameters in each query
+          ["object_name"].each do |param|
+            validation_errors << MISSING_QUERY_PARAMETER % [param,index] unless query.has_key?(param)
+          end
+          #Validate parameters type in each query
+          {"object_name" => String, "object_alias" => String }.each do |param, expected_type|
+            if query.has_key?(param) && !query[param].instance_of?(expected_type)
+              validation_errors << BAD_TYPE_QUERY_PARAMETER % { :param => param, :index => index, :expected => expected_type, :actual => query[param].class }
+            end
           end
-        else
-          @logger.error("Bad syntax for conf file #{file_conf} in query #{query}. Missing parameter #{param}.")
-          return false
-        end
-      end
-    end
 
-    @logger.debug('Check optional parameters types for queries')
-    parameter = {'object_alias' => 'String'.class, 'attributes' => [].class}
-    parameter.each_key do |param|
-      conf_hash['queries'].each do |query|
-        if query.has_key?(param)
-          unless query[param].instance_of?(parameter[param])
-            @logger.error("Bad syntax for conf file #{file_conf} in query #{query}. Bad types for parameter #{param}, expecting #{parameter[param]}, found #{conf_hash[param].class}.")
-            return false
+          if query.has_key?("attributes") && !query["attributes"].respond_to?(:each)
+            validation_errors << BAD_TYPE_QUERY_PARAMETER % { :param => 'attributes', :index => index, :expected => Enumerable, :actual => query['attributes'].class }
           end
         end
       end
     end
-
-    true
+    return validation_errors
   end
 
   private
@@ -215,8 +197,6 @@ class LogStash::Inputs::Jmx < LogStash::Inputs::Base
   # Thread function to retrieve metrics from JMX
   private
   def thread_jmx(queue_conf,queue)
-    require 'jmx4r'
-
     while true
       begin
         @logger.debug('Wait config to retrieve from queue conf')
@@ -317,43 +297,45 @@ class LogStash::Inputs::Jmx < LogStash::Inputs::Base
 
   public
   def register
-    @logger.info('Registering files in', :path => @path)
+    require 'thread'
+    require 'jmx4r'
 
-    @logger.info('Create queue conf used to send jmx conf to jmx collector threads')
+    @logger.info("Create queue dispatching JMX requests to threads")
     @queue_conf = Queue.new
 
-    @logger.info('Compile regexp for group alias object replacement')
+    @logger.info("Compile regexp for group alias object replacement")
     @regexp_group_alias_object = Regexp.new('(?:\${(.*?)})+')
   end
 
   public
   def run(queue)
-    require 'thread'
-
     begin
       threads = []
-      @logger.info("Init #{@nb_thread} jmx collector threads")
+      @logger.info("Initialize #{@nb_thread} threads for JMX metrics collection")
       @nb_thread.times do
         threads << Thread.new { thread_jmx(@queue_conf,queue) }
       end
 
       while true
-        @logger.info("Load conf files in #{@path}")
+        @logger.info("Loading configuration files in path", :path => @path)
         Dir.foreach(@path) do |item|
+          next if item == '.' or item == '..'
           begin
-            next if item == '.' or item == '..'
             file_conf = File.join(@path, item)
-            @logger.debug("Load conf file #{file_conf}")
-            conf_hash = read_conf(file_conf)
-            if check_conf(conf_hash,file_conf)
-              @logger.debug("Add conf #{conf_hash} to the queue conf")
+            @logger.debug? && @logger.debug("Loading configuration from file", :file => file_conf)
+            config_string = File.read(file_conf)
+            conf_hash = LogStash::Json.load(config_string)
+            validation_errors = validate_configuration(conf_hash)
+            if validation_errors.empty?
+              @logger.debug? && @logger.debug("Add configuration to the queue", :config => conf_hash)
               @queue_conf << conf_hash
+            else
+              @logger.warn("Issue with configuration file", :file => file_conf,
+              :validation_errors => validation_errors)
             end
           rescue Exception => ex
-            @logger.warn("Issue parsing file #{file_conf}")
-            @logger.warn(ex.message)
-            @logger.warn(ex.backtrace.join("\n"))
-            next
+            @logger.warn("Issue loading configuration from file", :file => file_conf,
+              :exception => ex.message, :backtrace => ex.backtrace)
           end
         end
         @logger.debug('Wait until the queue conf is empty')

data/logstash-input-jmx.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-input-jmx'
-  s.version         = '0.1.4'
+  s.version         = '0.1.5'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Retrieve metrics from jmx."
   s.description     = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"
@@ -25,5 +25,6 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'jmx4r'
 
   s.add_development_dependency 'logstash-devutils'
+  s.add_development_dependency 'logstash-codec-plain'
 end
 

data/spec/inputs/jmx_spec.rb

@@ -1 +1,82 @@
+# encoding: utf-8
 require "logstash/devutils/rspec/spec_helper"
+require "logstash/inputs/jmx"
+require "logstash/codecs/plain"
+require 'stud/temporary'
+
+describe LogStash::Inputs::Jmx do
+
+  let(:jmx_config_path) { Stud::Temporary.directory }
+  after(:each) do
+    FileUtils.remove_dir(jmx_config_path)
+  end
+
+  subject { LogStash::Inputs::Jmx.new("path" => jmx_config_path)}
+
+  context "#validate_configuration(conf_hash)" do
+    #Reference to error messages
+    MISSING_CONFIG_PARAMETER = LogStash::Inputs::Jmx::MISSING_CONFIG_PARAMETER
+    BAD_TYPE_CONFIG_PARAMETER = LogStash::Inputs::Jmx::BAD_TYPE_CONFIG_PARAMETER
+    BAD_TYPE_QUERY = LogStash::Inputs::Jmx::BAD_TYPE_QUERY
+    MISSING_QUERY_PARAMETER = LogStash::Inputs::Jmx::MISSING_QUERY_PARAMETER
+    BAD_TYPE_QUERY_PARAMETER = LogStash::Inputs::Jmx::BAD_TYPE_QUERY_PARAMETER
+
+    let(:minimal_config) { {"host"=>"localhost","port"=>1234,"queries" => [] } }
+
+    context "global configuration" do
+      it "return [] for valid configuration" do
+        #Minimal configuration
+        expect(subject.validate_configuration(minimal_config)).to eq([])
+        # Re-test with java objects from JrJackson serialization
+        if LogStash::Environment.jruby?
+          require "java"
+          expect(subject.validate_configuration({"host"=>"localhost","port"=>1234,"queries" => java.util.ArrayList.new})).to eq([])
+        end
+      end
+
+      it "return error message for missing mandatory parameters" do
+        expect(subject.validate_configuration({})).to eq([MISSING_CONFIG_PARAMETER % "host", MISSING_CONFIG_PARAMETER % "port", MISSING_CONFIG_PARAMETER % "queries"])
+      end
+
+      it "return error message for invalid parameters type" do
+        expect(subject.validate_configuration({"host"=>1234,"port"=>1234,"queries" => []})).to eq([BAD_TYPE_CONFIG_PARAMETER % {:param => "host", :expected => String, :actual => Fixnum}])
+        expect(subject.validate_configuration({"host"=>"localhost","port"=>"1234","queries" => []})).to eq([BAD_TYPE_CONFIG_PARAMETER % {:param => "port", :expected => Fixnum, :actual => String}])
+        expect(subject.validate_configuration({"host"=>"localhost","port"=>1234,"queries" => "my_query"})).to eq([BAD_TYPE_CONFIG_PARAMETER % {:param => "queries", :expected => Enumerable, :actual => String}])
+      end
+    end
+
+    context "query objects in configuration" do
+      it "return [] for valid query message" do
+        #Minimal query object
+        minimal_config["queries"] = [{"object_name" => "minimal"}]
+        expect(subject.validate_configuration(minimal_config)).to eq([])
+        #Full query object
+        minimal_config["queries"] = [{
+          "object_name" => "java.lang:type=Runtime",
+          "attributes" => [ "Uptime", "StartTime" ],
+          "object_alias" => "Runtime"}]
+        expect(subject.validate_configuration(minimal_config)).to eq([])
+      end
+      it "return error message for invalid query object type" do
+        minimal_config["queries"] = [ "1234" ]
+        expect(subject.validate_configuration(minimal_config)).to eq([BAD_TYPE_QUERY % { :index => 0, :expected => Hash, :actual => String }])
+      end
+
+      it "return error message for missing mandatory query parameter" do
+        minimal_config["queries"] = [ {} ]
+        expect(subject.validate_configuration(minimal_config)).to eq([MISSING_QUERY_PARAMETER % ["object_name",0] ])
+      end
+
+      it "return error message for invalid query parameters type" do
+        minimal_config["queries"] = [ { "object_name" => 1234} ]
+        expect(subject.validate_configuration(minimal_config)).to eq([BAD_TYPE_QUERY_PARAMETER % {:param => "object_name", :index => 0, :expected => String, :actual => Fixnum} ])
+
+        minimal_config["queries"] = [ { "object_name" => "1234", "object_alias" => 1234} ]
+        expect(subject.validate_configuration(minimal_config)).to eq([BAD_TYPE_QUERY_PARAMETER % {:param => "object_alias", :index => 0, :expected => String, :actual => Fixnum} ])
+
+        minimal_config["queries"] = [ { "object_name" => "1234", "attributes" => 1234} ]
+        expect(subject.validate_configuration(minimal_config)).to eq([BAD_TYPE_QUERY_PARAMETER % {:param => "attributes", :index => 0, :expected => Enumerable, :actual => Fixnum} ])
+      end
+    end
+  end
+end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-jmx
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-04-20 00:00:00.000000000 Z
+date: 2015-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: logstash-core
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -19,10 +20,7 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: 2.0.0
-  name: logstash-core
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -30,34 +28,50 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: 2.0.0
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
+  name: jmx4r
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: jmx4r
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: logstash-devutils
   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: '0'
-  name: logstash-devutils
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: logstash-codec-plain
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
 description: This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program
 email: info@elastic.co
 executables: []