fluent-plugin-network-probe 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fc2a98b51c2a9854113057dccad5cfbf17585f3f
+  data.tar.gz: c7e9132c1fa5b8270208905de9f6ea1995e57658
+SHA512:
+  metadata.gz: ec9e4e3bbc906c397c4301492f4bcdd8a843bfbf08f95c5df290636d7056a69993cdef206d7792696df3957227a12617aa2886828282980e156601e028df8e68
+  data.tar.gz: bdeaaf68ae983121038167aefa698fe96ce34fdbdbbd685c28a94f43371501f6b2d66cbe504a97930f4e8ac61795e2f8280654797456379dc31392ac0334b10c

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+vendor/*
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    fluent-plugin-network-probe (0.0.1)
+      eventmachine
+      fluentd (>= 0.10.7)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    cool.io (1.1.1)
+      iobuffer (>= 1.0.0)
+    eventmachine (1.0.3)
+    fluentd (0.10.40)
+      cool.io (~> 1.1.1)
+      http_parser.rb (~> 0.5.1)
+      json (>= 1.4.3)
+      msgpack (>= 0.4.4, < 0.6.0, != 0.5.3, != 0.5.2, != 0.5.1, != 0.5.0)
+      yajl-ruby (~> 1.0)
+    http_parser.rb (0.5.3)
+    iobuffer (1.1.2)
+    json (1.8.1)
+    msgpack (0.5.6)
+    rake (10.1.0)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fluent-plugin-network-probe!
+  rake

data/README.textile

@@ -0,0 +1,72 @@
+h1. Fluent::Plugin::NetworkProbe
+
+Fluentd input plugin to probe network latency and keepalive, similar to Smokeping.
+Now support methods are fping and curl.
+
+
+h2. Installation
+
+h3. Install tools
+
+on Ubuntu12.04
+
+<pre>
+$ sudo apt-get install fping curl
+</pre>
+
+h3. Install fluent plugin
+
+Add this line to your application's Gemfile:
+
+<pre>
+gem 'fluent-plugin-network-probe'
+</pre>
+
+Or install it yourself as:
+
+<pre>
+$ gem install fluent-plugin-network-probe
+</pre>
+
+Or use td-agent : (on Ubuntu12.04)
+
+<pre>
+$ sudo /usr/lib/fluent/ruby/bin/fluent-gem install fluent-plugin-network-probe
+</pre>
+
+
+
+h2. Configuration
+
+<pre>
+<source>
+  type config_expander
+
+  <config>
+    type network_probe
+    probe_type fping
+    target google.com
+    tag network_probe.${hostname}.fping
+    fping_count 5              # optional: default 5(count)
+    fping_timeout 2            # optional: default 2(sec)
+    fping_interval 1           # optional: default 1(sec)
+    fping_path /usr/bin/fping  # optional: default '/usr/bin/fping'
+  </config>
+</source>
+
+<source>
+  type config_expander
+
+  <config>
+    type network_probe
+    probe_type curl
+    target google.com
+    tag network_probe.${hostname}.curl
+    curl_count 5              # optional: default 5(count)
+    curl_timeout 2            # optional: default 2(sec)
+    curl_interval 1           # optional: default 1(sec)
+    curl_path /usr/bin/curl   # optional: default '/usr/bin/curl'
+  </config>
+</source>
+</pre>
+

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.test_files  = Dir['test/plugin/*.rb']
+  test.ruby_opts = ['-rubygems'] if defined? Gem
+  test.ruby_opts << '-I.'
+  test.verbose = true
+end
+
+task :default => :test
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/fluent-plugin-network-probe.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "fluent-plugin-network-probe"
+  gem.version     = File.read("VERSION").strip
+  gem.authors     = ["Yuichi UEMURA"]
+  gem.email       = ["yuichi.u@gmail.com"]
+  gem.homepage    = "https://github.com/u-ichi/fluent-plugin-network-probe"
+  gem.summary     = %q{Fluentd input plugin to probe network latency and keepalive, similar to smokeping}
+  gem.description = %q{Fluentd input plugin to probe network latency and keepalive, similar to smokeping}
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "fluentd", ">= 0.10.7"
+  gem.add_dependency "eventmachine"
+
+  gem.add_development_dependency "rake"
+end
+

data/lib/fluent/plugin/in_network_probe.rb

@@ -0,0 +1,133 @@
+module Fluent
+  class NetworkProbeInput < Input
+    Fluent::Plugin.register_input("network_probe", self)
+
+    config_param :probe_type
+    config_param :target
+
+    config_param :interval,          :default => 60               # sec
+
+    config_param :fping_count,       :default => 5               # number
+    config_param :fping_timeout,     :default => 2                # sec
+    config_param :fping_interval,    :default => 1                # sec
+    config_param :fping_path,        :default => '/usr/bin/fping'
+
+    config_param :curl_count,        :default => 5               # number
+    config_param :curl_timeout,      :default => 2                # sec
+    config_param :curl_interval,     :default => 1                # sec
+    config_param :curl_path,         :default => '/usr/bin/curl'
+
+    config_param :tag,               :default => "network_probe"
+    config_param :debug_mode,        :default => false
+
+    def initialize
+      require "eventmachine"
+
+      super
+    end
+
+    def configure(conf)
+      super
+
+      @conf = conf
+    end
+
+    def start
+      super
+      @thread = Thread.new(&method(:run))
+      $log.info "starting network probe, target #{@target} probe_type #{@probe_type}."
+    end
+
+    def shutdown
+      super
+      @thread.kill
+    end
+
+    def run
+      init_eventmachine
+      EM.run do
+        EM.add_periodic_timer(@interval) do
+          begin
+            EM.defer do
+              Engine.emit("#{@tag}_#{@target}", Engine.now, exec_fping) if @probe_type == 'fping'
+            end
+            EM.defer do
+              Engine.emit("#{@tag}_#{@target}", Engine.now, exec_curl) if @probe_type == 'curl'
+            end
+          rescue => ex
+            $log.warn("EM.periodic_timer loop error.")
+            $log.warn("#{ex}, tracelog : \n#{ex.backtrace.join("\n")}")
+          end
+        end
+      end
+    end
+
+    def exec_fping
+      cmd = "#{@fping_path} -i #{@fping_interval*1000} -T #{@fping_timeout} -c #{@fping_count} #{@target} -s"
+
+      cmd_results = run_cmd(cmd)
+
+      round_trip_times = Hash.new(nil)
+
+      cmd_results[1].split("\n").each do |line|
+        if /([^\s]*) ms \(min round trip time\)/=~ line
+           round_trip_times[:min] = $1.to_f
+        end
+        if /([^\s]*) ms \(avg round trip time\)/=~ line
+           round_trip_times[:avg]= $1.to_f
+        end
+        if /([^\s]*) ms \(max round trip time\)/=~ line
+           round_trip_times[:max] = $1.to_f
+        end
+      end
+
+      round_trip_times
+    end
+
+
+    def exec_curl
+      cmd = "#{@curl_path} #{@target} -w \%\{time_total\} -m #{@curl_timeout}"
+
+      result_times = []
+
+      @curl_count.times do
+        cmd_results = run_cmd(cmd)
+        result_times << cmd_results[0].split("\n").last.to_f * 1000
+        sleep @curl_interval
+      end
+
+      results = {}
+
+      results[:max] = result_times.max
+      results[:min] = result_times.min
+      results[:avg] = result_times.inject(0.0){|r,i| r+=i }/result_times.size
+
+      results
+    end
+
+    private
+
+    def init_eventmachine
+      unless EM.reactor_running?
+        EM.epoll; EM.kqueue
+        EM.error_handler do |ex|
+          $log.fatal("Eventmachine problem")
+          $log.fatal("#{ex}, tracelog : \n#{ex.backtrace.join("\n")}")
+        end
+      end
+    end
+
+    def run_cmd(cmd)
+      require "open3"
+      begin
+        results = Open3.capture3(cmd)
+        return results
+      rescue =>e
+        $log.warn "[SystemCommond]E:" + e
+        return false
+      end
+    end
+
+  end
+end
+

data/test/plugin/in_network_probe_curl.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'test_helper'
+require 'lib/fluent/plugin/in_network_probe.rb'
+require 'pp'
+
+
+class NetworkProbeCurlInputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    probe_type curl
+    target google.co.jp
+  ]
+
+  def create_driver(conf=CONFIG)
+    Fluent::Test::InputTestDriver.new(Fluent::NetworkProbeInput).configure(conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal 'curl',          d.instance.probe_type
+    assert_equal 'google.co.jp',      d.instance.target
+  end
+
+  def test_curl
+    d = create_driver
+
+    pp d.instance.exec_curl
+  end
+
+
+  def test_get_events
+    d = create_driver
+
+    # d.instance.before_events = before_events_stub
+  end
+
+  def test_get_usage
+    d = create_driver
+
+    # d.instance.get_usages
+  end
+
+end
+
+
+

data/test/plugin/in_network_probe_fping.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'test_helper'
+require 'lib/fluent/plugin/in_network_probe.rb'
+require 'pp'
+
+
+class NetworkProbeFpingInputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    probe_type fping
+    target localhost
+  ]
+
+
+  def create_driver(conf=CONFIG)
+    Fluent::Test::InputTestDriver.new(Fluent::NetworkProbeInput).configure(conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal 'localhost',      d.instance.target
+    assert_equal 'fping',          d.instance.probe_type
+  end
+
+  def test_fping
+    d = create_driver
+
+    d.instance.exec_fping
+  end
+
+
+  def test_get_events
+    d = create_driver
+
+    # d.instance.before_events = before_events_stub
+  end
+
+  def test_get_usage
+    d = create_driver
+
+    # d.instance.get_usages
+  end
+
+end
+
+
+
+
+
+

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fluent/test'
+
+unless ENV.has_key?('VERBOSE')
+  nulllogger = Object.new
+  nulllogger.instance_eval {|obj|
+    def method_missing(method, *args)
+      # pass
+    end
+  }
+  $log = nulllogger
+end
+
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-network-probe
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuichi UEMURA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fluentd input plugin to probe network latency and keepalive, similar
+  to smokeping
+email:
+- yuichi.u@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.textile
+- Rakefile
+- VERSION
+- fluent-plugin-network-probe.gemspec
+- lib/fluent/plugin/in_network_probe.rb
+- test/plugin/in_network_probe_curl.rb
+- test/plugin/in_network_probe_fping.rb
+- test/test_helper.rb
+homepage: https://github.com/u-ichi/fluent-plugin-network-probe
+licenses: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Fluentd input plugin to probe network latency and keepalive, similar to smokeping
+test_files:
+- test/plugin/in_network_probe_curl.rb
+- test/plugin/in_network_probe_fping.rb
+- test/test_helper.rb