mysampler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4adc593e649aa58ffb331e5ec1ee89432e25fd9a
+  data.tar.gz: 7fe23cf3f0aa2206aebae8a98066b7c287dbf1b2
+SHA512:
+  metadata.gz: 34212bb64ca530d7e3dfc12dc6ce47e25b93466ca380d82ce617a13aff2aec6462ba037b498e1547ca033fca7e3741ef283c3d2b009a646f0f1b9e964b8afb26
+  data.tar.gz: de9470ccf9822970cbebf9e5892c1e3b02eb763d17acb98786cf953dfc3b06cf5717df9631608bc830ff334c76e0142dcc034d62099fbc329a0dc52ecb3f9496

data/.gitignore

@@ -0,0 +1,2 @@
+*.swp
+*.pid

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 2.1.1@mysampler --create --install

data/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,53 @@
+MySampler
+=========
+
+What is it?
+-----------
+MySampler is a tool written in ruby to poll SHOW GLOBAL STATUS in MySQL and output the values to either a CSV or graphite/carbon.
+The interval at which the polling occurs can be specified and the output can be either the absolute or relative values, so you can see change over time.
+If logging to CSV, the a date stamp is appended to the CSV file and it is rotated hourly (to be configurable later).
+
+Dependencies
+------------
+
+MySampler requires the following gems:
+
+graphite
+sequel
+
+Installation
+------------
+To install, simply install the dependencies above, and clone the repository and run mysample.rb
+
+    gem install sequel
+    gem install graphite
+    git clone https://github.com/9minutesnooze/mysampler.git
+    cd mysampler
+    ./mysample.rb -o csv -u me -p secret -H localhost -f /tmp/mysample.csv -i 10 -r -d -k start
+
+Options
+-------
+    Usage ./mysample.rb [OPTIONS]
+    -u, --user USER                  MySQL User
+    -p, --pass PASSWORD              MySQL Password
+    -P, --port PORT                  MySQL port (default 3306)
+        --pidfile PIDFILE            PID File (default: `pwd`/mysample.pid)
+    -H, --host HOST                  MySQL hostname (default: localhost)
+    -f, --file FILENAME              output filename (will be appended with rotation timestamp)
+    -o, --output (csv|graphite)      Output format (default: csv)
+    -i, --sleep SECONDS              Interval between runs (default: 10)
+    -r, --relative                   Show the difference between the current and previous values (default: false)
+    -d, --daemonize                  daemonize process (default: false)
+    -k (start|stop|status)           command to pass daemon
+        --command
+    -g, --graphite HOST:PORT         Graphite server:port
+    -h, --help                       this message
+
+If daemonized with -d, currently STDERR/STDOUT does not go anywhere, so if you are having problems, try running it without the -d flag initially.
+
+Caveats
+-------
+This project, while it runs in production, is rapidly changing so the command line parameters and output are not set in stone.  
+I will attempt to write release notes if something changes drastically.
+Currently a lot of the object structure is being revamped and I am adding more features such as SHOW MUTEX STATUS, and SHOW ENGINE INNODB STATUS.  
+Those features are initially available in the class_refactor branch.

data/bin/mysampler

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/mysampler'
+require 'optparse'
+require 'sequel'
+require 'logger'
+
+$options = { :dbuser    => nil,
+             :dbpass    => nil,
+             :dbhost    => "localhost",
+             :dbport    => 3306,
+             :dbsocket  => nil,
+             :daemonize => false,
+             :pidfile   => Dir.pwd + "/mysample.pid",
+             :interval  => 10, #seconds
+             :command   => MySampler::ProcessCtl::STARTCMD ,
+             :output    => MySampler::Client::CSVOUT,
+             :relative  => false,
+             :graphitehost => nil, }
+
+opts = OptionParser.new
+opts.banner = "Usage #{$0} [OPTIONS]"
+opts.on("-u", "--user USER",     String,  "MySQL User" )  { |v|  $options[:dbuser] = v }
+opts.on("-p", "--pass PASSWORD", String,  "MySQL Password" )  { |v|  $options[:dbpass] = v }
+opts.on("-P", "--port PORT",     Integer, "MySQL port (default #{$options[:dbport]})" )  { |v|  $options[:dbport] = v }
+opts.on("--pidfile PIDFILE",     String,  "PID File (default: #{$options[:pidfile]})" )  { |v|  $options[:pidfile] = v }
+opts.on("-H", "--host HOST",     String,  "MySQL hostname (default: #{$options[:dbhost]})" )  { |v|  $options[:dbhost] = v }
+opts.on("-f", "--file FILENAME", String,  "output filename (will be appended with rotation timestamp)" )  { |v|  $options[:outputfn] = v }
+opts.on("-o", "--output (csv|graphite)", String, "Output format (default: csv)" ) do |v| 
+  $options[:output] = case v
+    when "yaml"
+      MySampler::Client::YAMLOUT
+    when "csv"
+      MySampler::Client::CSVOUT
+    when "graphite"
+      require 'graphite/logger'
+      MySampler::Client::GRAPHITEOUT
+    else
+      puts opts
+      exit 1
+  end
+end
+opts.on("-i", "--sleep SECONDS", Integer, "Interval between runs (default: #{$options[:interval]})" )  { |v|  $options[:interval] = v }
+opts.on("-r", "--relative","Show the difference between the current and previous values (default: #{$options[:relative]})" )  { |v|  $options[:relative] = v }
+opts.on("-d", "--daemonize", "daemonize process (default: #{$options[:daemonize]})" )  { |v|  $options[:daemonize] = true }
+opts.on("-k", "--command (start|stop|status)", String, "command to pass daemon") do |v|
+  $options[:command] = case v
+    when "stop"
+      MySampler::ProcessCtl::STOPCMD
+    when "status"
+      MySampler::ProcessCtl::STATUSCMD
+    when "start"
+      MySampler::ProcessCtl::STARTCMD
+    else
+      puts opts
+      exit 1
+  end
+end
+opts.on("-g", "--graphite HOST:PORT", String, "Graphite server:port") { |v| $options[:graphitehost] = v }
+opts.on("-h", "--help",  "this message") { puts opts; exit 1}
+opts.parse!
+
+pc = MySampler::ProcessCtl.new
+pc.daemonize = $options[:daemonize]
+pc.pidfile   = $options[:pidfile]
+
+
+ms = MySampler::Client.new
+ms.user     = $options[:dbuser]
+ms.pass     = $options[:dbpass]
+ms.host     = $options[:dbhost]
+ms.port     = $options[:dbport]
+ms.socket   = $options[:dbsocket]
+ms.interval = $options[:interval]
+ms.output   = $options[:output]
+ms.relative = $options[:relative]
+ms.outputfn = $options[:outputfn] if $options[:outputfn]
+ms.rotateinterval = MySampler::FileRotating::HOUR
+ms.graphitehost = $options[:graphitehost] if ms.output == MySampler::Client::GRAPHITEOUT
+
+case $options[:command]
+when MySampler::ProcessCtl::STOPCMD
+  pc.stop { puts "I'm done" }
+when MySampler::ProcessCtl::STATUSCMD
+  exit pc.status
+else
+  exit pc.start { ms.run }
+end

data/lib/mysampler/client.rb

@@ -0,0 +1,170 @@
+require 'sequel'
+
+module MySampler
+class Client
+  CSVOUT, YAMLOUT,GRAPHITEOUT = 0,1,2
+  attr_accessor :user, :pass, :port, :socket, :host, :interval, :output, :relative, :outputfn, :rotateinterval, :graphitehost
+
+  def initialize
+    @user           = nil
+    @pass           = nil
+    @port           = 3306
+    @socket         = nil
+    @host           = "localhost"
+    @query          = 'SHOW /*!50002 GLOBAL */ STATUS'
+    @interval       = 10
+    @relative       = false
+    @output         = CSVOUT
+    @prev_rows      = {}
+    @outputfn       = nil
+    @rotateinterval = FileRotating::HOUR
+    @rf             = nil
+    @graphitehost   = nil
+    @graphite       = nil
+    @mysql_hostname = nil
+  end
+
+  def run
+    @sequel = db_connect
+    if @output == GRAPHITEOUT 
+      get_mysql_hostname 
+      conn_to_graphite if @output == GRAPHITEOUT
+    else
+      headers = get_header_rows
+      open_rotating_file(:header => headers.join(","), :interval => @rotateinterval) 
+    end
+
+    first_run = true
+    loop do
+      begin
+        rows = @sequel[@query].to_hash(:Variable_name,:Value)
+        rows = values_to_numeric(rows)
+        rows = calc_relative(rows) if @relative
+        rows = scale_values(rows) 
+        output_query(rows) unless first_run && @relative
+        first_run = false
+      rescue Exception => e
+        STDERR.puts "An error occurred #{e}"
+      end
+
+      sleep @interval
+    end
+    @rf.close if @rf && @outputfn
+  end
+
+  # get the real hostname of the MySQL Server that we are connected to
+  def get_mysql_hostname 
+    @mysql_hostname = @sequel["SELECT @@hostname;"].first[:@@hostname]
+  end
+
+  def get_header_rows
+    @sequel[@query].to_hash(:Variable_name,:Value).keys
+  end
+
+  def output_header(rows)
+    @rf.puts(header) if @rf && @outputfn
+  end
+
+  def conn_to_graphite
+    @graphite = Graphite::Logger.new(@graphitehost)
+#    @graphite.logger = Logger.new('graphite.out')
+  end
+
+  def open_rotating_file (params)
+    @rf = @outputfn ? FileRotating.new(params, @outputfn, "w") : STDOUT
+  end
+
+  def is_counter? (key)
+    # list lovingly stolen from pt-mysql-summary
+    !%w[ Compression Delayed_insert_threads Innodb_buffer_pool_pages_data 
+         Innodb_buffer_pool_pages_dirty Innodb_buffer_pool_pages_free 
+         Innodb_buffer_pool_pages_latched Innodb_buffer_pool_pages_misc 
+         Innodb_buffer_pool_pages_total Innodb_data_pending_fsyncs 
+         Innodb_data_pending_reads Innodb_data_pending_writes 
+         Innodb_os_log_pending_fsyncs Innodb_os_log_pending_writes 
+         Innodb_page_size Innodb_row_lock_current_waits Innodb_row_lock_time_avg 
+         Innodb_row_lock_time_max Key_blocks_not_flushed Key_blocks_unused 
+         Key_blocks_used Last_query_cost Max_used_connections Ndb_cluster_node_id 
+         Ndb_config_from_host Ndb_config_from_port Ndb_number_of_data_nodes 
+         Not_flushed_delayed_rows Open_files Open_streams Open_tables 
+         Prepared_stmt_count Qcache_free_blocks Qcache_free_memory 
+         Qcache_queries_in_cache Qcache_total_blocks Rpl_status 
+         Slave_open_temp_tables Slave_running Ssl_cipher Ssl_cipher_list 
+         Ssl_ctx_verify_depth Ssl_ctx_verify_mode Ssl_default_timeout 
+         Ssl_session_cache_mode Ssl_session_cache_size Ssl_verify_depth 
+         Ssl_verify_mode Ssl_version Tc_log_max_pages_used Tc_log_page_size 
+         Threads_cached Threads_connected Threads_running 
+         Uptime_since_flush_status ].include? key
+  end
+
+  def calc_relative(rows)
+    result = {}
+    rows.each do |k,v|
+      if @prev_rows[k] && numeric?(v) && is_counter?(k)
+        result[k] = v - @prev_rows[k]
+      else 
+        result[k] = v
+      end
+    end
+    @prev_rows = rows
+    return result
+  end
+
+  def prefix_keys ( h, prefix )
+    Hash[h.map { |k,v| [ "#{prefix}#{k}", v] }]
+  end
+
+  def numeric? (value)
+    true if Float(value) rescue false
+  end
+
+  def to_numeric (value)
+    numeric?(value) ? value.to_i : value
+  end
+
+  # scale the value to be per @interval if recording relative values
+  # since it doesn't make much sense to output values that are "per 5 seconds"
+  def scale_value (value)
+    (@relative && numeric?(value)) ? (value/@interval) : value
+  end
+  
+  def scale_values ( rows )
+    Hash[rows.map do |k,v| 
+      is_counter?(k) ? [k, scale_value(v)] : [k, v]
+    end]  
+  end
+  
+  def values_to_numeric ( h )
+    Hash[h.map { |k,v| [ k, to_numeric(v)] }]
+  end
+
+  def output_query (rows )
+    case @output
+    when YAMLOUT then
+#      result = YAML::dump({time => Time.now, rows})
+    when GRAPHITEOUT then
+      graphite_rows = prefix_keys(rows, "mysql.#{@mysql_hostname.split('.').reverse.join('.')}.")
+      @graphite.log(Time.now.to_i, graphite_rows) if @graphite
+    else # CSVOUT 
+      @rf.puts(hash_to_csv(rows)) if @rf && @outputfn
+    end
+    true
+  end
+
+  def hash_to_csv ( rows, header = false )
+    str = header ?  "Time" : "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}" 
+    rows.sort.each { |v| str += header ? ",#{v[0]}" : ",#{v[1]}" } 
+    return str
+  end
+
+  def db_connect
+    params = { :host => @host, 
+               :user => @user, 
+               :port => @port,
+               :password => @pass }
+    params[:socket] = @socket if @socket    
+    @sequel = Sequel.mysql(params)
+  end
+end
+
+end

data/lib/mysampler/file.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby
+
+require 'yaml'
+module MySampler
+
+class FileRotating
+  YEAR, MONTH, DAY, HOUR, MINUTE, SECOND = 0,1,2,3,4,5
+
+  attr_accessor :header
+
+  def initialize (params, *args)
+    @interval = params[:interval] || DAY
+    @header   = params[:header]   || nil  # a header to put at the top of every file
+    @args = args
+    @root_fn = args[0]
+    @stamp = get_date_stamp
+
+    open_local do |f|
+      f.puts @header if @header
+      if block_given? 
+        return yield f
+      else 
+        return f
+      end
+    end
+  end
+
+  def close 
+    if @f
+      @f.flock(File::LOCK_UN)
+      @f.close 
+    end
+  end
+
+private
+  def open_local
+    fn = sprintf("%s.%s",@root_fn,@stamp)
+    args = @args
+    args[0] = fn
+#    puts fn
+
+    begin
+      @f = File.open(*args) 
+      @f.flock(File::LOCK_EX) if @f
+      if block_given?
+        return yield self
+      else
+        return self
+      end
+    end
+  end
+
+
+  def get_date_stamp
+    format = case @interval
+      when YEAR   then '%Y'
+      when MONTH  then '%Y%m'
+      when DAY    then '%Y%m%d'
+      when HOUR   then '%Y%m%d%H'
+      when MINUTE then '%Y%m%d%H%M'
+      when SECOND then '%Y%m%d%H%M%S'
+      else raise "Invalid interval"
+    end
+    return Time.now.strftime(format)
+  end
+
+  def method_missing(method, *args, &block)
+    # check to see if we need to reopen
+    stamp = get_date_stamp
+
+    if @stamp != stamp
+      @stamp = stamp
+      close 
+      open_local 
+      @f.puts @header if @header
+    end
+    return @f.send(method, *args, &block)       
+  end
+
+end
+
+#FileRotating.new({:interval => FileRotating::SECOND, :header => "Header!!!"}, "/tmp/foo.txt", "w") do |f|
+#  5.times do
+#    f.puts Time.now
+#    f.puts "Foo!"
+#    sleep 1
+#  end
+#end
+
+end

data/lib/mysampler/processctl.rb

@@ -0,0 +1,92 @@
+module MySampler
+class ProcessCtl
+  STARTCMD, STOPCMD, STATUSCMD = 0,1,2
+
+  attr_accessor :pidfile, :daemonize
+
+
+  def initialize
+    @pidfile = ""
+    @daemonize = false
+    @pid = nil
+  end
+
+
+  def start
+    trap(:INT)     { stop }
+    trap(:SIGTERM) { cleanup }
+
+    size = get_running_pids.size
+    if size > 0
+      puts "Daemon is already running"
+      return 1
+    end
+
+#    Daemonize.daemonize if @daemonize
+    if @daemonize
+      #http://stackoverflow.com/questions/1740308/create-a-daemon-with-double-fork-in-ruby
+      raise 'First fork failed' if (pid = fork) == -1
+      exit unless pid.nil?
+
+      Process.setsid
+      raise 'Second fork failed' if (pid = fork) == -1
+      exit unless pid.nil?
+
+      Dir.chdir '/'
+      File.umask 0000
+      STDIN.reopen '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen STDOUT
+    end
+    write_pid unless pidfile == ""
+    yield
+    return 0
+  end
+
+  def stop
+    # call user code if defined
+    begin 
+      yield 
+    rescue
+    end
+    get_running_pids.each do |pid|
+      puts "Killing pid #{pid}"
+      Process.kill :SIGTERM, pid
+      # can't do anything below here.  Process is dead
+    end
+    return 0
+  end
+
+  # returns the exit status (1 if not running, 0 if running)
+  def status
+    size = get_running_pids.size
+    puts "#{File.basename $0} is #{"not " if size < 1}running."
+    return (size > 0) ? 0 : 1
+  end
+
+protected
+  def cleanup
+    File.delete(@pidfile) if File.file?(@pidfile) 
+    exit 0
+  end
+
+  def write_pid
+    @pid = Process.pid
+    File.open(@pidfile, "w") do |f|
+#      f.write($$)
+      f.write(Process.pid)
+    end
+  end
+
+  def get_running_pids
+    return [@pid] if @pid
+    result = []
+    if File.file? @pidfile
+      pid = File.read @pidfile
+      # big long line I stole to kill a pid
+      result =  `ps -p #{pid} -o pid | sed 1d`.to_a.map!{|x| x.to_i}
+    end
+    return result
+  end
+end
+end

data/lib/mysampler/version.rb

@@ -0,0 +1,3 @@
+module MySampler
+  VERSION = "0.0.1"
+end

data/lib/mysampler.rb

@@ -0,0 +1,4 @@
+require_relative 'mysampler/client'
+require_relative 'mysampler/file'
+require_relative 'mysampler/processctl'
+require_relative 'mysampler/version'

data/mysampler.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mysampler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mysampler"
+  spec.version       = MySampler::VERSION
+  spec.authors       = ["Aaron Brown"]
+  spec.email         = ["aaron@9minutesnooze.com"]
+  spec.summary       = %q{A utility that logs MySQL statistics to CSV or graphite.}
+  spec.description   = %q{MySampler is a tool written in ruby to poll SHOW GLOBAL STATUS in MySQL and output the values to either a CSV or graphite/carbon. The interval at which the polling occurs can be specified and the output can be either the absolute or relative values, so you can see change over time. If logging to CSV, the a date stamp is appended to the CSV file and it is rotated hourly (to be configurable later).}
+  spec.homepage      = "https://github.com/9minutesnooze/mysampler"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  %w{mysql sequel graphite}.each { |gem| spec.add_dependency gem }
+end

data/spec/tests.rb

@@ -0,0 +1,65 @@
+require 'timecop'
+require 'mysqlsampler'
+
+
+describe "database connectivity" do
+  before(:all) do
+    @ms = MySQLSampler.new
+    @ms.user     = "aaron"
+    @ms.pass     = "n0m0r3181"
+    @ms.host     = "locutus.borg.lan"
+    @ms.port     = 3306
+    @ms.db_connect
+  end
+
+  it "should return 'locutus.borg.lan'" do
+    @ms.get_mysql_hostname.should == @ms.host 
+  end
+
+  it "should return an array that includes 'Uptime'" do
+    @ms.get_header_rows.should include('Uptime')
+  end
+
+end
+
+describe "Row operations" do
+  before(:all) do
+    Timecop.freeze(Time.local(2011,10,17,0,0,0))
+    @ms = MySQLSampler.new
+  end
+
+  after(:all) do
+    Timecop.return
+  end
+
+  # test relative operation
+  it "should return a key with 2 as the value" do
+    @ms.calc_relative({"Foo" => 4})
+    h = @ms.calc_relative({"Foo" => 6})
+    h["Foo"].should == 2
+  end
+
+  it "should prefix key with 'foo.'" do
+    h = @ms.prefix_keys({"bar" => 1}, "foo.")
+    h.keys.first.should == "foo.bar"
+  end
+
+  it "should convert a string to a numeric if it is a number" do
+    @ms.to_numeric("5").should == 5
+  end
+
+  it "should not convert a string to a numeric if it is a string" do
+    @ms.to_numeric("a").should == "a"
+  end
+
+  it "should convert a hash of string numbers to numbers" do
+    h = @ms.values_to_numeric({"a" => "1"})
+    h["a"].should == 1
+  end
+
+  it "should convert a hash into a comma separated csv prefixed by time" do
+    h = { "a" => 1, "b" => 2, "c" => "foo" }
+    @ms.hash_to_csv(h).should == "2011-10-17 00:00:00,1,2,foo"
+  end
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: mysampler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aaron Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: mysql
+  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: sequel
+  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: graphite
+  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'
+description: MySampler is a tool written in ruby to poll SHOW GLOBAL STATUS in MySQL
+  and output the values to either a CSV or graphite/carbon. The interval at which
+  the polling occurs can be specified and the output can be either the absolute or
+  relative values, so you can see change over time. If logging to CSV, the a date
+  stamp is appended to the CSV file and it is rotated hourly (to be configurable later).
+email:
+- aaron@9minutesnooze.com
+executables:
+- mysampler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rvmrc"
+- Gemfile
+- README.md
+- bin/mysampler
+- lib/mysampler.rb
+- lib/mysampler/client.rb
+- lib/mysampler/file.rb
+- lib/mysampler/processctl.rb
+- lib/mysampler/version.rb
+- mysampler.gemspec
+- spec/tests.rb
+homepage: https://github.com/9minutesnooze/mysampler
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A utility that logs MySQL statistics to CSV or graphite.
+test_files:
+- spec/tests.rb