monitoring-client 0.2.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in monitoring.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    monitoring (0.0.1)
+      json
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json (1.5.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  monitoring!

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/monitoringd

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+module Monitoring
+  class Daemon
+
+    require "optparse"
+    require "thread"
+    require "socket"
+    require "json"
+    require "net/https"
+    require "uri"
+    require "timeout"
+
+    RC_OK = 0
+    RC_USAGE = 1
+    RC_KILLED = 2
+    
+    
+    def initialize()
+      @udp_port = 57475
+      @daemon_mode = false
+      @monitoring_endpoint = "http://metrics.trim.za.net"
+      @pid_file_fn = "/var/run/monitoringd.pid"
+      @sleep_period = 60
+      @stdout = "/dev/null"
+      @stderr = "/dev/null"
+      @alive = true
+    end
+    
+
+    def parse_opts(argv)
+      optparser = OptionParser.new() do |o|
+        o.banner = "monitoringd [options]"
+
+        o.separator("")
+        o.separator("options")
+
+        o.on("-p", "--udp-port=PORT",
+             "Port to listen on",
+             "Default: #{@udp_port}") do |v|
+          @udp_port = Integer(v)
+        end
+        
+        o.on("-f", "--forgeround",
+             "Run in forground",
+             "Default: #{!@daemon_mode}") do |v|
+          @daemon_mode = !v
+        end
+
+        o.on("--monitoring-endpoint=URI",
+             "Endpoint to post to",
+             "Default: " + @monitoring_endpoint.inspect()) do |v|
+          @monitoring_endpoint = v
+        end
+        
+        o.on("--pid-file=FILE",
+             "Place to store our pid file",
+             "Default: " + @pid_file_fn.inspect()) do |v|
+          @pid_file_fn = v
+        end
+
+        o.on("--sleep-period=s",
+             "Time to sleep between posts",
+             "Default: #{@sleep_period}") do |v|
+          @sleep_period = Float(v)
+        end
+
+        o.on("--stdout=FILE",
+             "Place to write stdout to",
+             "Default: " + @stdout.inspect()) do |v|
+          @stdout = v
+        end
+
+        o.on("--stderr=FILE",
+             "Place to write stdout to",
+             "Default: " + @stderr.inspect()) do |v|
+          @stderr = v
+        end
+        
+        o.separator("")
+        o.on_tail("-h", "--help", "You're reading it :-)") do
+          puts(o)
+          Kernel.exit(RC_USAGE)
+        end
+      end
+
+      optparser.parse(argv)
+      self
+    end
+
+    def run()
+      daemonize() if @daemon_mode
+
+      trap(:INT) do
+        if @alive
+          STDOUT.puts("SIGINT: going away gracefully")
+          @alive = false
+        else
+          STDOUT.puts("SIGINT (again): going away not so gracefully")
+          Kernel.exit!(RC_KILLED)
+        end
+      end
+
+      @samples = Queue.new()
+      server = Thread.new { collect_samples() }
+      uri = URI.parse(@monitoring_endpoint)
+      while @alive
+        samples_to_post = []
+        samples_to_post.push(@samples.pop()) until @samples.empty?
+        post_samples(uri, samples_to_post) unless samples_to_post.empty?
+        Kernel.sleep(@sleep_period)
+      end
+      #server.join()
+    end
+
+    def daemonize()
+      pid_file_fd = File.open(@pid_file_fn, "w")
+      pid_file_fd.flock(File::LOCK_EX | File::LOCK_NB) ||
+        die("Daemon already exists")
+
+      die("First fork failed") if (pid = Kernel.fork()) == -1
+      exit unless pid.nil?
+
+      Process.setsid
+      pid_file_fd.puts(Process.pid)
+
+      Dir.chdir("/")
+      File.umask(0000)
+      STDIN.reopen("/dev/null")
+      STDOUT.reopen(@stdout)
+      STDERR.reopen(@stderr)
+    end
+
+    def die(why)
+      STDERR.puts(why)
+      Kernel.exit!(1)
+    end
+
+    def collect_samples()
+      socket = UDPSocket.new
+      socket.bind(nil, @udp_port)
+      while @alive
+        begin
+          line = socket.gets()
+          JSON.parse(line).each do |sample|
+            @samples.push(sample)
+          end
+        rescue Exception => e;
+          STDOUT.puts("Could not parse " + line.inspect()) rescue nil
+          STDERR.puts([[e.class.name, e.message].join(": "),
+                       e.backtrace.join("\n")].join("\n")) rescue nil
+        end
+      end
+    end
+    
+    def post_samples(uri, samples)
+      Timeout.timeout(3) do
+        generic_http_post(uri, "/api/samples", nil, nil, { "samples" => samples.to_json })
+      end
+    rescue Timeout::Error => e
+      STDOUT.puts("Could not post sample (will requeue): " + samples.inspect()) rescue nil
+      STDERR.puts([[e.class.name, e.message].join(": "),
+                   e.backtrace.join("\n")].join("\n")) rescue nil
+      samples.each do |s| @samples.push(s) end
+    rescue Exception => e
+      STDOUT.puts("Could not post sample (will not requeue): " + samples.inspect()) rescue nil
+      STDERR.puts([[e.class.name, e.message].join(": "),
+                   e.backtrace.join("\n")].join("\n")) rescue nil
+    end
+
+    def generic_http_post(uri, path, user, pass, post_params={}, &block)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.is_a?(URI::HTTPS)
+      req = Net::HTTP::Post.new(path)
+      req.set_form_data(post_params)
+      req.basic_auth(user, pass) if user and pass
+      resp = http.request(req)
+      
+      raise RuntimeError, resp.class.name unless resp.is_a?(Net::HTTPSuccess)
+      
+      if block_given?
+        block.call(resp.body)
+      else
+        resp.body
+      end
+    end
+    
+  end
+end
+
+Monitoring::Daemon.new().parse_opts(ARGV).run()

data/lib/monitoring.rb

@@ -0,0 +1,5 @@
+module Monitoring
+  module Client
+    require "monitoring/client/version"
+  end
+end

data/lib/monitoring/client/metric.rb

@@ -0,0 +1,21 @@
+module Monitoring
+  module Client
+    class Metric
+
+      attr_accessor :units
+      attr_reader :value
+      
+      def initialize(metric_name)
+        @value = nil
+      end
+
+
+      def value=(v)
+        raise(ArgumentError, "Must be a Fixnum or Float") unless
+          [Fixnum, Float].any? { |c| c === v }
+        @value = v
+      end
+      
+    end
+  end
+end

data/lib/monitoring/client/profiler.rb

@@ -0,0 +1,24 @@
+module Monitoring
+  module Client
+    class Profiler
+
+      require "json"
+      require "socket"
+      require "monitoring/client/routine"
+      
+
+      def initialize(program_name)
+        @program_name = program_name
+      end
+
+
+      def routine(routine_name)
+        routine = Routine.new(routine_name)
+        yield(routine)
+        UDPSocket.new().send(routine.compile(@program_name).to_json + "\n",
+                             0, "localhost", 57475)
+      end
+      
+    end
+  end
+end

data/lib/monitoring/client/routine.rb

@@ -0,0 +1,41 @@
+module Monitoring
+  module Client
+    class Routine
+
+      require "monitoring/client/metric"
+
+      
+      def initialize(routine_name)
+        @routine_name = routine_name
+        @metrics = Hash.new do |h, k| h[k] = Metric.new(k) end
+      end
+
+
+      def time(metric_name = "time")
+        t0 = Time.now.to_f
+        yield
+        @metrics[metric_name].value = Time.now.to_f - t0
+        @metrics[metric_name].units = "s"
+      end
+      
+      def count(metric_name, increment_by, units = nil)
+        @metrics[metric_name].value = (@metrics[metric_name].value || 0) + increment_by
+        @metrics[metric_name].units = units
+      end
+
+      def compile(program_name)
+        @metrics.inject([]) do |compilation, metric_tuple|
+          metric_name, metric = metric_tuple
+          compilation.push({
+                             "program_name" => program_name,
+                             "routine_name" => @routine_name,
+                             "metric_name" => metric_name,
+                             "metric_units" => metric.units,
+                             "sample_value" => metric.value,
+                           })
+        end
+      end
+      
+    end
+  end
+end

data/lib/monitoring/client/version.rb

@@ -0,0 +1,5 @@
+module Monitoring
+  module Client
+    VERSION = "0.2.0"
+  end
+end

data/monitoring-client.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "monitoring/client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "monitoring-client"
+  s.version     = Monitoring::Client::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Marc Bowes"]
+  s.email       = ["marcbowes+monitoring+client@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/monitoring-client"
+  s.summary     = %q{Simple client & daemon to post metrics}
+  s.description = %q{Ruby client which uses UDP to communicate with a daemon which uses HTTP POST to communicate with a Web server}
+
+  s.rubyforge_project = "monitoring-client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_runtime_dependency "json"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: monitoring-client
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Marc Bowes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Ruby client which uses UDP to communicate with a daemon which uses HTTP POST to communicate with a Web server
+email: 
+- marcbowes+monitoring+client@gmail.com
+executables: 
+- monitoringd
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- bin/monitoringd
+- lib/monitoring.rb
+- lib/monitoring/client/metric.rb
+- lib/monitoring/client/profiler.rb
+- lib/monitoring/client/routine.rb
+- lib/monitoring/client/version.rb
+- monitoring-client.gemspec
+has_rdoc: true
+homepage: http://rubygems.org/gems/monitoring-client
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: monitoring-client
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Simple client & daemon to post metrics
+test_files: []
+