logstash-perftool 0.1.0

data/lib/lsperfm.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+require 'lsperfm/core'
+
+module LogStash
+  module PerformanceMeter
+
+    extend self
+
+    def invoke
+      debug   = !!ENV['DEBUG']
+      headers = !!ENV['HEADERS']
+
+      install_path  = ARGV.size > 1 ? ARGV[1] : Dir.pwd
+      definition    = ARGV.size > 0 ? ARGV[0] : ""
+
+      runner = LogStash::PerformanceMeter::Core.new(definition, install_path)
+      runner.config = '.lsperfm' if File.exist?('.lsperfm.yml')
+      puts runner.run(debug, headers).join("\n")
+    end
+
+  end
+end

data/lib/lsperfm/core.rb

@@ -0,0 +1,81 @@
+require 'lsperfm/core/reporter'
+require 'lsperfm/core/run'
+
+module LogStash::PerformanceMeter
+
+  class ConfigException < Exception; end
+
+  class Core
+
+    attr_reader :definition, :install_path, :runner, :config
+
+    def initialize(definition, install_path, config='', runner = LogStash::PerformanceMeter::Runner)
+      @definition   = definition
+      @install_path = install_path
+      @runner       = runner
+      @config       = load_config(config)
+    end
+
+    def run(debug=false, headers=false)
+      tests    = load_tests(definition)
+      lines    = (headers ? ["name, #{runner.headers.join(',')}"] : [])
+      reporter = LogStash::PerformanceMeter::Reporter.new.start
+      tests.each do |test|
+        events  = test[:events].to_i
+        time    = test[:time].to_i
+
+        manager = runner.new(find_test_config(test[:config]), debug, install_path)
+        metrics = manager.run(events, time, runner.read_input_file(find_test_input(test[:input])))
+        lines << formatter(test[:name], metrics)
+      end
+      lines
+    rescue Errno::ENOENT => e
+      raise ConfigException.new(e)
+    ensure
+      reporter.stop if reporter
+    end
+
+    def config=(config)
+      @config = load_config(config)
+    end
+
+    private
+
+    def load_tests(definition)
+      return load_default_tests if definition.empty?
+      eval(IO.read(definition))
+    end
+
+    def load_default_tests
+      require 'lsperfm/defaults/suite.rb'
+      LogStash::PerformanceMeter::DEFAULT_SUITE
+    end
+
+    def load_config(config)
+      ::YAML::load_file(config)['default'] rescue {}
+    end
+
+    def find_test_config(file)
+      return file if config.empty?
+      File.join(config['path'], config['config'], file)
+    end
+
+    def find_test_input(file)
+      return file if config.empty?
+      File.join(config['path'], config['input'], file)
+    end
+
+    def formatter(test_name, args={})
+      percentile =   args[:percentile]
+      [
+        "%s"   %           test_name,
+        "%.2f" %   args[:start_time],
+        "%.2f" %      args[:elapsed],
+        "%.0f" % args[:events_count],
+        "%.0f" % (args[:events_count] / args[:elapsed]),
+        "%.2f" % percentile.last,
+        "%.0f" % (percentile.reduce(:+) / percentile.size)
+      ].join(',')
+    end
+  end
+end

data/lib/lsperfm/core/reporter.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module LogStash
+  module PerformanceMeter
+    class Reporter
+      def start
+        @reporter = Thread.new do
+          loop do
+            $stderr.print '.'
+            sleep 1
+          end
+        end
+        self
+      end
+
+      def stop
+        @reporter.kill
+      end
+    end
+  end
+end

data/lib/lsperfm/core/run.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+require "benchmark"
+require "thread"
+require "open3"
+
+require 'lsperfm/core/stats'
+
+Thread.abort_on_exception = true
+
+module LogStash::PerformanceMeter
+
+  class Runner
+    LOGSTASH_BIN  = File.join("bin", "logstash").freeze
+
+    INITIAL_MESSAGE = ">>> lorem ipsum start".freeze
+    LAST_MESSAGE = ">>> lorem ipsum stop".freeze
+    REFRESH_COUNT = 100
+
+    attr_reader :command
+
+    def initialize(config, debug = false, logstash_home = Dir.pwd)
+      @debug = debug
+      @command = [File.join(logstash_home, LOGSTASH_BIN), "-f", config]
+    end
+
+    def run(required_events_count, required_run_time, input_lines)
+      puts("launching #{command.join(" ")} #{required_events_count} #{required_run_time}") if @debug
+      stats = LogStash::PerformanceMeter::Stats.new
+      real_events_count = 0
+      Open3.popen3(*@command) do |i, o, e|
+        puts("sending initial event") if @debug
+        start_time = Benchmark.realtime do
+          i.puts(INITIAL_MESSAGE)
+          i.flush
+
+          puts("waiting for initial event") if @debug
+          expect_output(o, /#{INITIAL_MESSAGE}/)
+        end
+
+        puts("starting output reader thread") if @debug
+        reader = stats.detach_output_reader(o, /#{LAST_MESSAGE}/)
+        puts("starting feeding input") if @debug
+
+        elapsed = Benchmark.realtime do
+          real_events_count = feed_input_with(required_events_count, required_run_time, input_lines, i)
+          puts("waiting for output reader to complete") if @debug
+          reader.join
+        end
+        { :percentile => percentile(stats.stats, 0.80) , :elapsed => elapsed, :events_count => real_events_count, :start_time => start_time }
+      end
+    end
+
+    def self.headers
+      ["start time", "elapsed", "events", "avg tps", "best tps", "avg top 20% tps"]
+    end
+
+    def feed_input_with(required_events_count, required_run_time, input_lines, i)
+      if required_events_count > 0
+        feed_input_events(i, [required_events_count, input_lines.size].max, input_lines, LAST_MESSAGE)
+      else
+        feed_input_interval(i, required_run_time, input_lines, LAST_MESSAGE)
+      end
+    end
+
+    def self.read_input_file(file_path)
+      IO.readlines(file_path).map(&:chomp)
+    end
+
+    def feed_input_events(io, events_count, lines, last_message)
+      loop_count = (events_count / lines.size).ceil # how many time we send the input file over
+      (1..loop_count).each{lines.each {|line| io.puts(line)}}
+
+      io.puts(last_message)
+      io.flush
+
+      loop_count * lines.size
+    end
+
+    private
+
+    def feed_input_interval(io, seconds, lines, last_message)
+      loop_count = (2000 / lines.size).ceil # check time every ~2000(ceil) input lines
+      lines_per_iteration = loop_count * lines.size
+      start_time = Time.now
+      count = 0
+
+      while true
+        (1..loop_count).each{lines.each {|line| io.puts(line)}}
+        count += lines_per_iteration
+        break if (Time.now - start_time) >= seconds
+      end
+
+      io.puts(last_message)
+      io.flush
+
+      count
+    end
+
+    def expect_output(io, regex)
+      io.each_line do |line|
+        puts("received: #{line}") if @debug
+        yield if block_given?
+        break if line =~ regex
+      end
+    end
+
+    def percentile(array, percentile)
+      count = (array.length * (1.0 - percentile)).floor
+      array.sort[-count..-1]
+    end
+
+  end
+
+  def extract_options(args)
+    options = {}
+    while !args.empty?
+      config = args.shift.to_s.strip
+      option = args.shift.to_s.strip
+      raise(IllegalArgumentException, "invalid option for #{config}") if option.empty?
+      case config
+      when "--events"
+        options[:events] = option
+      when "--time"
+        options[:time] = option
+      when "--config"
+        options[:config] = option
+      when "--input"
+        options[:input] = option
+      when "--headers"
+        options[:headers] = option
+      else
+        raise(IllegalArgumentException, "invalid config #{config}")
+      end
+    end
+
+    options
+
+  end
+end

data/lib/lsperfm/core/stats.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require "thread"
+
+Thread.abort_on_exception = true
+
+module LogStash::PerformanceMeter
+
+  class Stats
+
+    REFRESH_COUNT = 100
+
+    attr_accessor :stats
+
+    def initialize
+      @stats = []
+    end
+    # below stats counter and output reader threads are sharing state using
+    # the @stats_lock mutex, @stats_count and @stats. this is a bit messy and should be
+    # refactored into a proper class eventually
+
+    def detach_stats_counter
+      Thread.new do
+        loop do
+          start = @stats_lock.synchronize{@stats_count}
+          sleep(1)
+          @stats_lock.synchronize{@stats << (@stats_count - start)}
+        end
+      end
+    end
+
+    # detach_output_reader spawns a thread that will fill in the @stats instance var with tps samples for every seconds
+    # @stats access is synchronized using the @stats_lock mutex but can be safely used
+    # once the output reader thread is completed.
+    def detach_output_reader(io, regex)
+      Thread.new(io, regex) do |io, regex|
+        i = 0
+        @stats = []
+        @stats_count = 0
+        @stats_lock = Mutex.new
+        t = detach_stats_counter
+
+        expect_output(io, regex) do
+          i += 1
+          # avoid mutex synchronize on every loop cycle, using REFRESH_COUNT = 100 results in
+          # much lower mutex overhead and still provides a good resolution since we are typically
+          # have 2000..100000 tps
+          @stats_lock.synchronize{@stats_count = i} if (i % REFRESH_COUNT) == 0
+        end
+
+        @stats_lock.synchronize{t.kill}
+      end
+    end
+
+    def expect_output(io, regex)
+      io.each_line do |line|
+        puts("received: #{line}") if @debug
+        yield if block_given?
+        break if line =~ regex
+      end
+    end
+
+  end
+
+end

data/lib/lsperfm/defaults/config/complex_syslog.conf

@@ -0,0 +1,46 @@
+input {
+  stdin {
+    type => syslog
+  }
+}
+
+filter {
+  if [type] == "syslog" {
+    grok {
+      match => { "message" => "<%{POSINT:syslog_pri}>%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{PROG:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: %{GREEDYDATA:syslog_message}" }
+      add_field => [ "received_at", "%{@timestamp}" ]
+        add_field => [ "received_from", "%{syslog_hostname}" ]
+    }
+    syslog_pri { }
+    date {
+      match => ["syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
+    }
+
+    if [syslog_timestamp] {
+      mutate {
+        add_field => [ "[times][created_at]",  "%{syslog_timestamp}"]
+          add_field => [ "[times][received_at]",  "%{@timestamp}"]
+      }
+    }
+
+    mutate {
+      add_field => [ "[hosts][source]",  "%{received_from}"]
+        add_field => [ "[level][facility]",  "%{syslog_facility}"]
+        add_field => [ "[level][severity]",  "%{syslog_severity}"]
+    }
+
+    if !("_grokparsefailure" in [tags]) {
+      mutate {
+        replace => [ "@source_host", "%{syslog_hostname}" ]
+          replace => [ "@message", "%{syslog_message}" ]
+      }
+    }
+    mutate {
+      remove_field => [ "syslog_hostname", "syslog_message", "syslog_timestamp" ]
+    }
+  }
+}
+
+output {
+  stdout { codec => json_lines }
+}

data/lib/lsperfm/defaults/config/json_inout_codec.conf

@@ -0,0 +1,11 @@
+input {
+  stdin { codec => "json_lines" }
+}
+
+filter {
+  clone {}
+}
+
+output {
+  stdout { codec => json_lines }
+}

data/lib/lsperfm/defaults/config/json_inout_filter.conf

@@ -0,0 +1,11 @@
+input {
+  stdin {}
+}
+
+filter {
+  json { source => "message" }
+}
+
+output {
+  stdout { codec => json_lines }
+}

data/lib/lsperfm/defaults/config/simple.conf

@@ -0,0 +1,11 @@
+input {
+  stdin {}
+}
+
+filter {
+  clone {}
+}
+
+output {
+  stdout { codec => line }
+}

data/lib/lsperfm/defaults/config/simple_grok.conf

@@ -0,0 +1,13 @@
+input {
+  stdin { type => "apache" }
+}
+
+filter {
+  grok {
+    match => {"message" => "%{COMBINEDAPACHELOG}"}
+  }
+}
+
+output {
+  stdout { codec => line }
+}

data/lib/lsperfm/defaults/config/simple_json_out.conf

@@ -0,0 +1,11 @@
+input {
+  stdin {}
+}
+
+filter {
+  clone {}
+}
+
+output {
+  stdout { codec => json_lines }
+}