logstash-core 5.0.0.alpha3.snapshot5-java → 5.0.0.alpha3.snapshot6-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a41edc5a19188510be8f6b9e275f26d82538f4f
-  data.tar.gz: e389c454d1999160f6b2a1a750999ef26c620285
+  metadata.gz: eadab99495c889eb6e28493c540bdee17bd9720b
+  data.tar.gz: c895be838504aaa3d56b816f726e67c70c9d6b1e
 SHA512:
-  metadata.gz: b5871edf304c92f16a0bc33381894d497a06189fefc0858190d9b0a888db939074c14c515432727c4cfcdfba65159b898e2a1a42438ef40683bf507b122ffa46
-  data.tar.gz: 6e30b256b36652be4499ab4398bab002c34d68fe92b67e65b2fd04d9f89e42a21a13591f79ba4396a891b27890405d1073950b7e87d171fe7ac98902e794606d
+  metadata.gz: c2ccf45abb4062a722d4ddb20004157b72c1160173cfbe836f71ef7bb5c54194ed6fb1646799fa62129abd52a20a25a9043482834c50da364a26105e840867f3
+  data.tar.gz: 6d4c3652e704eb0e5f227a5e876bf6a70556760f35ed610950b4568d5efeda32671249f8cc87d7bfa968770deb73b350d1b7bed730feb3eafa579bbd60ad3d9c

data/lib/logstash-core/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_VERSION = "5.0.0-alpha3.snapshot5"
+LOGSTASH_CORE_VERSION = "5.0.0-alpha3.snapshot6"

data/lib/logstash/api/command_factory.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require "logstash/api/service"
+require "logstash/api/commands/system/basicinfo_command"
+require "logstash/api/commands/system/plugins_command"
+require "logstash/api/commands/stats"
+
+
+module LogStash
+  module Api
+    class CommandFactory
+      attr_reader :factory, :service
+
+      def initialize(service)
+        @service = service
+        @factory = {
+          :system_basic_info => ::LogStash::Api::Commands::System::BasicInfo,
+          :plugins_command => ::LogStash::Api::Commands::System::Plugins,
+          :stats => ::LogStash::Api::Commands::Stats
+        }
+      end
+
+      def build(*klass_path)
+        # Get a nested path with args like (:parent, :child)
+        klass = klass_path.reduce(factory) {|acc,v| acc[v]}
+
+        if klass
+          klass.new(service)
+        else
+          raise ArgumentError, "Class path '#{klass_path}' does not map to command!"
+        end
+      end
+    end
+  end
+end

data/lib/logstash/api/commands/base.rb

@@ -0,0 +1,25 @@
+module LogStash
+  module Api
+    module Commands
+      class Base
+        attr_reader :service
+        
+        def initialize(service = LogStash::Api::Service.instance)
+          @service = service
+        end
+
+        def hostname
+          service.agent.node_name
+        end
+
+        def uptime
+          service.agent.uptime
+        end
+
+        def started_at
+          (LogStash::Agent::STARTED_AT.to_f * 1000.0).to_i
+        end
+      end
+    end
+  end
+end

data/lib/logstash/api/commands/stats.rb

@@ -0,0 +1,105 @@
+require "logstash/api/commands/base"
+require 'logstash/util/thread_dump'
+
+module LogStash
+  module Api
+    module Commands
+      class Stats < Commands::Base
+
+        def jvm
+          {:threads => service.get_shallow(:jvm, :threads)}
+        end
+
+        def process
+          service.get_shallow(:jvm, :process)
+        end
+
+        def events
+          service.get_shallow(:stats, :events)
+        end
+
+        def memory
+          memory = LogStash::Json.load(service.get(:jvm_memory_stats))
+          {
+            :heap_used_in_bytes => memory["heap"]["used_in_bytes"],
+            :heap_used_percent => memory["heap"]["used_percent"],
+            :heap_committed_in_bytes => memory["heap"]["committed_in_bytes"],
+            :heap_max_in_bytes => memory["heap"]["max_in_bytes"],
+            :heap_used_in_bytes => memory["heap"]["used_in_bytes"],
+            :non_heap_used_in_bytes => memory["non_heap"]["used_in_bytes"],
+            :non_heap_committed_in_bytes => memory["non_heap"]["committed_in_bytes"],
+            :pools => memory["pools"].inject({}) do |acc, (type, hash)|
+              hash.delete("committed_in_bytes")
+              acc[type] = hash
+              acc
+            end
+          }
+        end
+
+        def hot_threads(options={})
+          HotThreadsReport.new(self, options)
+        end
+
+        class HotThreadsReport
+          HOT_THREADS_STACK_TRACES_SIZE_DEFAULT = 10.freeze
+          
+          def initialize(cmd, options)
+            @cmd = cmd
+            filter = { :stacktrace_size => options.fetch(:stacktrace_size, HOT_THREADS_STACK_TRACES_SIZE_DEFAULT) }
+            jr_dump = JRMonitor.threads.generate(filter)
+            @thread_dump = ::LogStash::Util::ThreadDump.new(options.merge(:dump => jr_dump))
+          end
+          
+          def to_s
+            hash = to_hash
+            report =  "#{I18n.t("logstash.web_api.hot_threads.title", :hostname => hash[:hostname], :time => hash[:time], :top_count => @thread_dump.top_count )} \n"
+            report << '=' * 80
+            report << "\n"
+            hash[:threads].each do |thread|
+              thread_report = ""
+              thread_report = "#{I18n.t("logstash.web_api.
+                                hot_threads.thread_title", :percent_of_cpu_time => thread[:percent_of_cpu_time], :thread_state => thread[:state], :thread_name => thread[:name])} \n"
+              thread_report = "#{thread[:percent_of_cpu_time]} % of of cpu usage by #{thread[:state]} thread named '#{thread[:name]}'\n"
+              thread_report << "#{thread[:path]}\n" if thread[:path]
+              thread[:traces].each do |trace|
+                thread_report << "\t#{trace}\n"
+              end
+              report << thread_report
+              report << '-' * 80
+              report << "\n"
+            end
+            report
+          end
+
+          def to_hash
+            hash = { :hostname => @cmd.hostname, :time => Time.now.iso8601, :busiest_threads => @thread_dump.top_count, :threads => [] }
+            @thread_dump.each do |thread_name, _hash|
+              thread_name, thread_path = _hash["thread.name"].split(": ")
+              thread = { :name => thread_name,
+                         :percent_of_cpu_time => cpu_time_as_percent(_hash),
+                         :state => _hash["thread.state"]
+                       }
+              thread[:path] = thread_path if thread_path
+              traces = []
+              _hash["thread.stacktrace"].each do |trace|
+                traces << trace
+              end
+              thread[:traces] = traces unless traces.empty?
+              hash[:threads] << thread
+            end
+            hash
+          end
+
+          def cpu_time_as_percent(hash)
+            (((cpu_time(hash) / @cmd.uptime * 1.0)*10000).to_i)/100.0
+          end
+
+          def cpu_time(hash)
+            hash["cpu.time"] / 1000000.0
+          end
+
+        end       
+      end
+    end
+  end
+end

data/lib/logstash/api/commands/system/basicinfo_command.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'logstash/api/commands/base'
+require "logstash/util/duration_formatter"
+
+module LogStash
+  module Api
+    module Commands
+      module System
+        class BasicInfo < Commands::Base
+
+          def run
+            {
+              "hostname" => hostname,
+              "version" => {
+                "number" => LOGSTASH_VERSION
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logstash/api/commands/system/plugins_command.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require "logstash/api/commands/base"
+
+module LogStash
+  module Api
+    module Commands
+      module System
+        class Plugins < Commands::Base
+          def run
+            { :total => plugins.count, :plugins => plugins }
+          end
+
+          private
+
+          def plugins
+            @plugins ||= find_plugins_gem_specs.map do |spec|
+              { :name => spec.name, :version => spec.version.to_s }
+            end.sort_by do |spec|
+              spec[:name]
+            end
+          end
+
+          def find_plugins_gem_specs
+            @specs ||= Gem::Specification.find_all.select{|spec| logstash_plugin_gem_spec?(spec)}
+          end
+
+          def logstash_plugin_gem_spec?(spec)
+            spec.metadata && spec.metadata["logstash_plugin"] == "true"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/logstash/api/modules/base.rb

@@ -0,0 +1,41 @@
+require "logstash/api/app_helpers"
+require "logstash/api/command_factory"
+
+module LogStash
+  module Api
+    module Modules
+      class Base < ::Sinatra::Base
+        helpers AppHelpers
+
+        attr_reader :factory
+
+        if settings.environment != :production
+          set :raise_errors, true
+          set :show_exceptions, :after_handler
+        end
+
+        include LogStash::Util::Loggable
+
+        helpers AppHelpers
+
+        def initialize(app=nil)
+          super(app)
+          @factory = ::LogStash::Api::CommandFactory.new(LogStash::Api::Service.instance)
+        end
+
+        not_found do
+          status 404
+          as   = params.has_key?("human") ? :string : :json
+          text = as == :string ? "" : {}
+          respond_with(text, :as => as)
+        end
+
+        error do
+          e = env['sinatra.error']
+          logger.error(e.message, :url => request.url, :ip => request.ip, :params => request.params, :class => e.class.name, :backtrace => e.backtrace)
+        end
+
+      end
+    end
+  end
+end

data/lib/logstash/api/modules/node.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module LogStash
+  module Api
+    module Modules
+      class Node < ::LogStash::Api::Modules::Base
+        # return hot threads information
+        get "/hot_threads" do
+          ignore_idle_threads = params["ignore_idle_threads"] || true
+
+          options = {
+            :ignore_idle_threads => as_boolean(ignore_idle_threads),
+            :human => params.has_key?("human")
+          }
+          options[:threads] = params["threads"].to_i if params.has_key?("threads")
+
+          stats = factory.build(:stats)
+          as    = options[:human] ? :string : :json
+          respond_with(stats.hot_threads(options), {:as => as})
+        end
+
+      end
+    end
+  end
+end

data/lib/logstash/api/modules/node_stats.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module LogStash
+  module Api
+    module Modules
+      class NodeStats < ::LogStash::Api::Modules::Base
+        
+        before do
+          @stats = factory.build(:stats)
+        end
+
+        # Global _stats resource where all information is
+        # retrieved and show
+        get "/" do          
+          payload = {
+            :events => events_payload,
+            :jvm => jvm_payload,
+            :process => process_payload
+          }
+
+          respond_with payload
+        end
+
+        # Show all events stats information
+        # (for ingested, emitted, dropped)
+        # - #events since startup
+        # - #data (bytes) since startup
+        # - events/s
+        # - bytes/s
+        # - dropped events/s
+        # - events in the pipeline
+        get "/events" do
+          respond_with({ :events => events_payload })
+        end
+
+        get "/jvm" do
+          respond_with :jvm => jvm_payload
+        end
+
+        get "/process" do
+          respond_with :process => process_payload
+        end
+
+        private
+
+        def events_payload
+          @stats.events
+        end
+
+        def jvm_payload
+          @stats.jvm
+        end
+
+        def process_payload
+          @stats.process
+        end
+      end
+    end
+  end
+end

data/lib/logstash/api/modules/plugins.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module LogStash
+  module Api
+    module Modules
+      class Plugins < ::LogStash::Api::Modules::Base
+
+        get "/" do
+          command = factory.build(:plugins_command)
+          respond_with(command.run())
+        end
+
+      end
+    end
+  end
+end

data/lib/logstash/api/modules/root.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module LogStash
+  module Api
+    module Modules
+      class Root < ::LogStash::Api::Modules::Base
+        
+        get "/" do
+          command = factory.build(:system_basic_info)
+          respond_with command.run
+        end
+        
+      end
+    end
+  end
+end

data/lib/logstash/api/modules/stats.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module LogStash
+  module Api
+    module Modules
+      class Stats < ::LogStash::Api::Modules::Base
+
+        def stats_command
+          factory.build(:stats)
+        end
+
+        # Global _stats resource where all information is 
+        # retrieved and show
+        get "/" do
+          payload = {
+            :events => stats_command.events,
+            :jvm => { :memory => stats_command.memory }
+          }
+          respond_with payload
+        end
+
+
+        # return hot threads information
+        get "/jvm" do
+          jvm_payload = {
+            :timestamp => stats_command.started_at,
+            :uptime_in_millis => stats_command.uptime,
+            :mem => stats_command.memory
+          }
+          respond_with({:jvm => jvm_payload})
+        end
+
+        # Show all events stats information
+        # (for ingested, emitted, dropped)
+        # - #events since startup
+        # - #data (bytes) since startup
+        # - events/s
+        # - bytes/s
+        # - dropped events/s
+        # - events in the pipeline
+        get "/events" do
+          respond_with({ :events => stats_command.events })
+        end
+
+        # return hot threads information
+        get "/jvm/hot_threads" do
+          top_threads_count = params["threads"] || 3
+          ignore_idle_threads = params["ignore_idle_threads"] || true
+          options = {
+            :threads => top_threads_count.to_i,
+            :ignore_idle_threads => as_boolean(ignore_idle_threads)
+          }
+
+          respond_with(stats_command.hot_threads(options))
+        end
+
+        # return hot threads information
+        get "/jvm/memory" do
+          respond_with({ :memory => stats_command.memory })
+        end
+      end
+    end
+  end
+end