graphite-api 0.0.0.23 → 0.0.0.24

data/README.md

@@ -1,21 +1,24 @@
-# GraphiteAPI
-A Ruby API toolkit for [Graphite](http://graphite.wikidot.com/)
+# GraphiteAPI [Beta]
+A Ruby API toolkit for [Graphite](http://graphite.wikidot.com/).
 
 ## Description
-Graphite Client and Utilities For Ruby
+Graphite client and utilities for ruby
 
 * **Simple** client for ruby.
-* Graphite **MiddleWare Server**, a lightweight, event-driven, aggregator daemon.
-* Light-Weight, only **ONE** depenency (event-machine)
-* **Utilities** like scheduling and caching.
+* Ships with a **GraphiteAPI-Middleware**, which is a lightweight, event-driven, aggregator daemon.
+* only one dependency (EventMachine).
+* Utilities like scheduling and caching.
+
+## Features
+* Multiple Graphite servers support - GraphiteAPI-Middleware supports sending aggregate data to multiple graphite servers, useful for large data centers and backup purposes
+* Reanimation mode - support cases which the same keys (with the same timestamps) can be received simultaneously and asynchronous from multiple input sources, in that cases GraphiteAPI-Middleware will "reanimate" old records that were already sent to Graphite server, and will send the sum of the reanimate record value + value of the just received record, to graphite server; this new summed record should override the key with the new value on Graphite database.
 
 ## Client Usage
 ```ruby
  	require 'graphite-api'
 
  	client = GraphiteAPI::Client.new(
-	 :host => "graphite.example.com",
- 	 :port => 2003,
+	 :graphite => "graphite.example.com:2003",
  	 :prefix => ["example","prefix"], # add example.prefix to each key
  	 :interval => 60                  # send to graphite every 60 seconds
  	)
@@ -39,23 +42,25 @@ Graphite Client and Utilities For Ruby
 	
  	client.join # wait...
 ```	
-## Middleware Usage
-
-`graphite-middleware --help`
+## GraphiteAPI-Middleware Usage
 
 ```
-Graphite Middleware Server
+[root@someplace]# graphite-middleware --help
+
+GraphiteAPI Middleware Server
 
 Usage: graphite-middleware [options]
-    -g, --graphite HOST              graphite host
+    -g, --graphite HOST:PORT         graphite host, in HOST:PORT format (can be specified multiple times)
     -p, --port PORT                  listening port (default 2003)
     -l, --log-file FILE              log file
     -L, --log-level LEVEL            log level (default warn)
     -P, --pid-file FILE              pid file (default /var/run/graphite-middleware.pid)
     -d, --daemonize                  run in background
     -i, --interval INT               report every X seconds (default 60)
-    -s, --slice SECONDS              send to graphite in X seconds slices (default is 60)
-    -c, --cache HOURS                cache expiration time in hours (default is 12 hours)
+    -s, --slice SECONDS              send to graphite in X seconds slices (default 60)
+    -r, --reanimation HOURS          reanimate records that are younger than X hours, please see README
+
+More Info @ https://github.com/kontera-technologies/graphite-api
 ```
 
 ## Installation
@@ -73,6 +78,11 @@ cd graphite-api
 rake install
 ```
 
+# TODO:
+* Documentation
+* trap signals and shutdown server
+* More tests
+
 ## Bugs
 
 If you find a bug, feel free to report it @ our [issues tracker](https://github.com/kontera-technologies/graphite-api/issues) on github.

data/Rakefile

@@ -2,10 +2,5 @@ $:.unshift File.join(File.dirname(__FILE__), 'lib')
 Dir.chdir File.dirname __FILE__
 
 require 'graphite-api'
-require 'bundler/setup'
-
-def msg m
-  $stderr.puts "[*] #{m}"
-end
 
 Dir['tasks/**/*.rake'].each { |rake| load rake }

data/lib/graphite-api.rb

@@ -1,18 +1,20 @@
 module GraphiteAPI
   ROOT = File.expand_path(File.dirname(__FILE__))
 
-  autoload :Version,    "#{ROOT}/graphite-api/version"
-  autoload :Client,     "#{ROOT}/graphite-api/client"
-  autoload :Scheduler,  "#{ROOT}/graphite-api/scheduler"
-  autoload :Connector,  "#{ROOT}/graphite-api/connector"
-  autoload :Middleware, "#{ROOT}/graphite-api/middleware"
-  autoload :Runner,     "#{ROOT}/graphite-api/runner"
-  autoload :Utils,      "#{ROOT}/graphite-api/utils"
-  autoload :Buffer,     "#{ROOT}/graphite-api/buffer"
-  autoload :Logger,     "#{ROOT}/graphite-api/logger"
-    
+  autoload :Version,         "#{ROOT}/graphite-api/version"
+  autoload :Client,          "#{ROOT}/graphite-api/client"
+  autoload :Scheduler,       "#{ROOT}/graphite-api/scheduler"
+  autoload :Connector,       "#{ROOT}/graphite-api/connector"
+  autoload :Middleware,      "#{ROOT}/graphite-api/middleware"
+  autoload :Runner,          "#{ROOT}/graphite-api/runner"
+  autoload :Utils,           "#{ROOT}/graphite-api/utils"
+  autoload :CLI,             "#{ROOT}/graphite-api/cli"
+  autoload :Buffer,          "#{ROOT}/graphite-api/buffer"
+  autoload :Logger,          "#{ROOT}/graphite-api/logger"
+  autoload :ConnectorGroup,  "#{ROOT}/graphite-api/connector_group"
+
   def self.version
-    GraphiteAPI::Version.string
+    GraphiteAPI::Version::VERSION
   end
   
-end
+end

data/lib/graphite-api/buffer.rb

@@ -9,7 +9,7 @@
 #     buff.stream "mem.usage 1"
 #     buff.stream "90 1326842563\n"
 #     buff.stream "shuki.tuki 999 1326842563\n"
-#     buff.each {|o| p o} 
+#     buff.pull.each {|o| p o} 
 #
 # Produce:
 #    ["load_avg", 40.0, 1326881160]
@@ -18,84 +18,101 @@
 # -----------------------------------------------------
 module GraphiteAPI
   class Buffer
-    attr_reader :leftovers,:options,:new_records,:in_cache_mode
 
-    def initialize(options)
+    attr_reader :options,:keys_to_send,:reanimation_mode, :streamer_buff
+
+    CLOSING_STREAM_CHAR = "\n"                    # end of message - when streaming to buffer obj
+    IGNORING_CHARS      = "\r"                    # remove these chars from message
+    FLOATS_ROUND_BY = 2                           # round(x) after joining floats 
+    VALID_RECORD = /^[\w|\.]+ \d+(?:\.|\d)* \d+$/ # how a valid record should look like
+    
+    def initialize options
       @options = options
-      @leftovers = Hash.new {|h,k| h[k] = Array.new}
-      @new_records = []
-      @in_cache_mode = !options[:cache_exp].nil?
-      start_cleaner if in_cache_mode
+      @keys_to_send  = Hash.new {|h,k| h[k] = []}
+      @streamer_buff = Hash.new {|h,k| h[k] = ""}
+      @reanimation_mode = !options[:reanimation_exp].nil?
+      start_cleaner if reanimation_mode
     end
 
-    def << hash
-      time = Utils.normalize_time(hash[:time],options[:slice])
-      hash[:metric].each do |k,v|
-        buffer[time][k] += v.to_f
-        new_records << [time,k]
-      end
+    def push hash
+      Logger.debug [:buffer,:add,hash]
+      time = Utils::normalize_time(hash[:time],options[:slice])
+      hash[:metric].each { |k,v| cache_set(time,k,v) }
     end
-
-    def stream(data,client_id = nil)
-      got_leftovers = data[-1,1] != "\n"
-      data = data.split(/\n/)
-      unless leftovers[client_id].empty?
-        if (valid leftovers[client_id].last + data.first rescue nil)
-          data.unshift(leftovers[client_id].pop + data.shift)
+    alias :<< :push
+    
+    def stream data, client_id = nil
+      data.each_char do |char|
+        next if invalid_char? char
+        streamer_buff[client_id] += char 
+        if char == CLOSING_STREAM_CHAR
+          push build_metric(*streamer_buff[client_id].split) if valid streamer_buff[client_id]
+          streamer_buff.delete client_id
         end
-        leftovers[client_id].clear
-      end
-
-      leftovers[client_id] << data.pop if got_leftovers
-      data.each do |line|
-        next unless valid line
-        key,val,time = line.split
-        self << {:metric => {key => val},:time => (Time.at(time.to_i) rescue Time.now)}
       end
     end
-
-    def each
-      new_records.uniq.each do |time,key|
-        yield [prefix + key,buffer[time][key],time]
-      end and clear
+    
+    def pull as = nil
+      Array.new.tap do |obj|
+        keys_to_send.each { |t, k| k.each { |o| obj.push cache_get(t, o, as) } }
+        clear
+      end
     end
     
     def empty?
-      buffer.empty?
+      buffer_cache.empty?
     end
 
     def got_new_records?
-      !new_records.empty?
+      !keys_to_send.empty?
     end
-
+    
     def size
-      buffer.values.map(&:values).flatten.size
-    end
+      buffer_cache.values.map {|o| o.values}.flatten.size
+    end # TODO: make it less painful
 
     private
+    def invalid_char?(char)
+      IGNORING_CHARS.include?(char)
+    end
+    
+    def cache_set(time, key, value)
+      buffer_cache[time][key] = (buffer_cache[time][key] + value.to_f).round(FLOATS_ROUND_BY)
+      keys_to_send[time].push(key) unless keys_to_send[time].include?(key)
+    end
+    
+    def cache_get(time, key, as)
+      metric = [prefix + key,buffer_cache[time][key],time]
+      as == :string ? metric.join(" ") : metric
+    end
+        
+    def build_metric key, value, time
+      { :metric => { key => value },:time => Time.at(time.to_i) }
+    end
+
     def clear
-      new_records.clear
-      buffer.clear unless in_cache_mode
+      keys_to_send.clear
+      buffer_cache.clear unless reanimation_mode
     end
     
-    def valid(data)
+    def valid data
       data =~ /^[\w|\.]+ \d+(?:\.|\d)* \d+$/
     end
     
     def prefix
-      @prefix ||= options[:prefix].empty? ? String.new : prefix_to_s 
+      @prefix ||= options[:prefix].empty? ? '' : prefix_to_s 
     end
     
     def prefix_to_s
-      [options[:prefix]].flatten.join('.') << "."
+      Array(options[:prefix]).join('.') << '.'
     end
     
-    def buffer
-      @buffer ||= Hash.new {|h,k| h[k] = Hash.new {|h1,k1| h1[k1] = 0}}
+    def buffer_cache
+      @buffer_cache ||= Hash.new {|h,k| h[k] = Hash.new {|h1,k1| h1[k1] = 0}}
     end
 
-    def clean(age)
-      [buffer,new_records].each {|o| o.delete_if {|t,k| now - t > age}}
+    def clean age
+      [buffer_cache,keys_to_send].each {|o| o.delete_if {|t,k| now - t > age}}
     end
     
     def now
@@ -103,7 +120,7 @@ module GraphiteAPI
     end
     
     def start_cleaner
-      Scheduler.every(options[:cleaner_interval]) { clean options[:cache_exp] }
+      Scheduler.every(options[:cleaner_interval]) { clean(options[:cache_exp]) }
     end
 
   end

data/lib/graphite-api/cli.rb

@@ -0,0 +1,57 @@
+require 'optparse'
+module GraphiteAPI
+  class CLI
+    
+    def self.parse(argv, options)
+      OptionParser.new do |opts| 
+        opts.banner = "GraphiteAPI Middleware Server"
+        opts.define_head "Usage: graphite-middleware [options]"
+        opts.define_head ""
+
+        opts.on("-g", "--graphite HOST:PORT","graphite host, in HOST:PORT format (can be specified multiple times)") do |graphite|
+          options[:backends] << Utils::expand_host(graphite)
+        end
+
+        opts.on("-p", "--port PORT","listening port (default #{options[:port]})") do |port|
+          options[:port] = port
+        end
+
+        opts.on("-l", "--log-file FILE","log file") do |file|
+          options[:log_file] = File::expand_path(file)
+        end
+
+        opts.on("-L", "--log-level LEVEL","log level (default warn)") do |level|
+          options[:log_level] = level
+        end
+
+        opts.on("-P", "--pid-file FILE","pid file (default #{options[:pid]})") do |pid_file|
+          options[:pid] = pid_file
+        end
+
+        opts.on("-d", "--daemonize","run in background") do 
+          options[:daemonize] = true
+        end
+
+        opts.on("-i", "--interval INT","report every X seconds (default #{options[:interval]})") do |x_seconds|
+          options[:interval] = x_seconds.to_i if x_seconds.to_i > 0
+        end
+
+        opts.on("-s", "--slice SECONDS","send to graphite in X seconds slices (default #{options[:slice]})") do |slice|
+          options[:slice] = slice.to_i if slice.to_i >= 0
+        end
+
+        opts.on("-r", "--reanimation HOURS","reanimate records that are younger than X hours, please see README") do |exp|
+          (options[:reanimation_exp] = exp.to_i * 3600) if exp.to_i > 0
+        end
+
+        opts.separator ""
+        opts.separator "More Info @ https://github.com/kontera-technologies/graphite-api"
+        opts.separator ""
+
+        opts.define_tail ""
+        opts.define_tail ""
+      end.parse! argv
+      options
+    end
+  end
+end

data/lib/graphite-api/client.rb

@@ -5,8 +5,7 @@
 # Usage
 #
 #  client = GraphiteAPI::Client.new(
-#    :host => "graphite.example.com",
-#    :port => 2003,
+#    :graphite => "graphite.example.com:2003",
 #    :prefix => ["example","prefix"], # add example.prefix to each key
 #    :interval => 60                  # send to graphite every 60 seconds
 #    )
@@ -32,12 +31,14 @@
 # -----------------------------------------------------
 module GraphiteAPI
   class Client
-    attr_reader :options,:buffer,:connector
+    include Utils
     
-    def initialize(opt)
-      @options   = GraphiteAPI::Utils.default_options.merge opt
-      @buffer    = GraphiteAPI::Buffer.new(options)
-      @connector = GraphiteAPI::Connector.new(*options.values_at(:host,:port))
+    attr_reader :options,:buffer,:connectors
+    
+    def initialize opt
+      @options    = build_options opt.clone
+      @buffer     = GraphiteAPI::Buffer.new(options)
+      @connectors = GraphiteAPI::ConnectorGroup.new(options)
       start_scheduler
     end
 
@@ -46,7 +47,7 @@ module GraphiteAPI
     end
 
     def join
-      sleep 1 while buffer.got_new_records?
+      sleep while buffer.got_new_records?
     end
     
     def stop
@@ -58,13 +59,23 @@ module GraphiteAPI
     end
 
     protected
+    
     def start_scheduler
-      Scheduler.every(options[:interval]) {send_metrics}
+      Scheduler.every(options[:interval]) { send_metrics }
     end
     
     def send_metrics
-      buffer.each {|arr| connector.puts arr.join(" ")} 
-    end 
+      connectors.publish buffer.pull(:string)
+    end
+    
+    def build_options opt
+      default_options.tap do |options_hash|
+        options_hash[:backends] << expand_host(opt.delete(:host)) if opt.has_key? :host
+        options_hash[:backends] << expand_host(opt.delete(:graphite))
+        options_hash.merge! opt
+        options_hash.freeze
+      end
+    end
     
   end
-end
+end

data/lib/graphite-api/connector.rb

@@ -9,33 +9,39 @@
 # => my.metric 1092 1232123231\n
 # -----------------------------------------------------
 require 'socket'
+
 module GraphiteAPI
   class Connector
-    attr_reader :options
+
+    attr_reader :options, :host, :port
     
     def initialize(host,port)
       @host = host
       @port = port
     end
     
-    def puts(msg)
+    def puts message
       begin
-        Logger.debug msg
-        socket.puts(msg)
+        Logger.debug [:connector,:puts,[host,port].join(":"),message]
+        socket.puts message
       rescue Errno::EPIPE
         @socket = nil
       retry
       end
     end
     
+    def inspect
+      "#{self.class} #{@host}:#{@port}"
+    end
+    
     protected
     
     def socket
       if @socket.nil? || @socket.closed?
-        @socket = TCPSocket.new(@host,@port)
+        @socket = ::TCPSocket.new(host,port)
       end
       @socket
     end
      
   end
-end
+end

data/lib/graphite-api/connector_group.rb

@@ -0,0 +1,17 @@
+module GraphiteAPI
+  class ConnectorGroup
+
+    attr_reader :options, :connectors
+
+    def initialize options
+      @options = options
+      @connectors = options[:backends].map { |o| Connector.new(*o) }
+    end
+
+    def publish messages
+      Logger.debug [:connector_group,:publish,messages.size, @connectors]
+      Array(messages).each { |msg| connectors.map {|c| c.puts msg} }
+    end
+    
+  end
+end

data/lib/graphite-api/middleware.rb

@@ -15,8 +15,9 @@
 #   prefix           add prefix to each key
 #   interval         report to graphite every X seconds (default is 60)
 #   slice            send to graphite in X seconds slices (default is 60)
-#   log_level        info # TODO: move this to runner.rb
+#   log_level        info 
 # -----------------------------------------------------
+
 require 'rubygems'
 require 'eventmachine'
 require 'logger'
@@ -27,45 +28,45 @@ module GraphiteAPI
 
     attr_reader :logger,:buffer,:client_id
 
-    def initialize(logger,buffer)
+    def initialize logger, buffer
       @logger = logger
       @buffer = buffer
       super
     end
 
     def post_init
-      logger.debug "Client connecting"
-      @client_id = Socket.unpack_sockaddr_in(get_peername).join(":")
+      @client_id = Socket.unpack_sockaddr_in(get_peername).reverse.join(":")
+      logger.debug [:middleware,:connecting,client_id]
     end
 
-    def receive_data(data)
-      buffer.stream(data,client_id)
+    def receive_data data
+      logger.debug [:middleware,:message,client_id,data]
+      buffer.stream data, client_id
     end
 
     def unbind
-      logger.debug "Client disconnecting"
+      logger.debug [:middleware,:disconnecting,client_id]
     end
 
-    def self.start(options)
+    def self.start options
       EventMachine.run do
         # Resources
         GraphiteAPI::Logger.logger = ::Logger.new(options[:log_file] || STDOUT)
         GraphiteAPI::Logger.level = eval "::Logger::#{options[:log_level].to_s.upcase}"
+        # TODO: move logger logic to runner
         
         buffer    = GraphiteAPI::Buffer.new(options)
-        connector = GraphiteAPI::Connector.new(*options.values_at(:graphite_host,:graphite_port))
+        connectors = GraphiteAPI::ConnectorGroup.new(options)
         
         # Starting server
-        EventMachine.start_server('0.0.0.0',options[:listening_port],self,GraphiteAPI::Logger.logger,buffer)
-        GraphiteAPI::Logger.info "Server running on port #{options[:listening_port]}"
+        EventMachine.start_server('0.0.0.0',options[:port],self,GraphiteAPI::Logger.logger,buffer)
+        GraphiteAPI::Logger.info "Server running on port #{options[:port]}"
         
         # Send metrics to graphite every X seconds
-        GraphiteAPI::Scheduler.every(options[:interval]) do
-          if buffer.got_new_records?
-            Logger.debug "Sending #{buffer.size} records to graphite (@#{options[:graphite_host]}:#{options[:graphite_port]})"
-            buffer.each { |arr| connector.puts arr.join(" ") }
-          end # if got_new_records?
+        GraphiteAPI::Scheduler.every( options[:interval] ) do
+          connectors.publish buffer.pull(:string) if buffer.got_new_records?
         end # every 
+        
       end # run 
     end # start
   end # Middleware

data/lib/graphite-api/runner.rb

@@ -2,68 +2,29 @@ require 'optparse'
 
 module GraphiteAPI
   class Runner
-    attr_reader :options
 
     def initialize(argv)
-      parser.parse! argv
+      GraphiteAPI::CLI::parse(argv,options)
       validate_options
     end
     
     def run
-      if options[:daemonize]
-        fork do
-          Process.setsid
-          exit if fork
-          Dir.chdir('/tmp')
-          STDOUT.reopen('/dev/null','a')
-          STDIN.reopen('/dev/null')
-          STDERR.reopen('/dev/null','a')
-          write_pid
-          run!
-        end
-      else
-        run!
-      end
+      options[:daemonize] ? daemonize(options[:pid]) { run! } : run!
     end
 
     private
-    def options
-      @options ||= Utils.default_options
-    end
     
-    def write_pid
-      begin
-        File.open(options[:pid], 'w') { |f| f.write(Process.pid) }
-      rescue Exception
-      end
-    end
-
     def run!
-      GraphiteAPI::Middleware.start(options)
+       Middleware::start options
     end
 
-    def validate_options
-      abort "You must specify graphite host" if options[:graphite_host].nil?
+    def options
+      @options ||= Utils::default_options
     end
 
-    def parser
-      OptionParser.new do |opts| 
-        opts.banner = "Graphite Middleware Server"
-        opts.define_head "Usage: graphite-middleware [options]"
-        opts.define_head ""
-        opts.on("-g", "--graphite HOST","graphite host") {|v| options[:graphite_host] = v}        
-        opts.on("-p", "--port PORT","listening port (default 2003)"){|v| options[:listening_port] = v}
-        opts.on("-l", "--log-file FILE","log file") {|v| options[:log_file] = File.expand_path(v)}
-        opts.on("-L", "--log-level LEVEL","log level (default warn)") {|v|options[:log_level] = v}
-        opts.on("-P", "--pid-file FILE","pid file (default /var/run/graphite-middleware.pid)"){|v|options[:pid] = v}
-        opts.on("-d", "--daemonize","run in background"){options[:daemonize] = true}
-        opts.on("-i", "--interval INT","report every X seconds (default 60)"){|v|options[:interval] = v.to_i unless v.to_i == 0}
-        opts.on("-s", "--slice SECONDS","send to graphite in X seconds slices (default is 60)") {|v| options[:slice] = v.to_i unless v.to_i == 0}
-        opts.on("-c", "--cache HOURS","cache expiration time in hours (default is 12 hours)") {|v| (options[:cache_exp] = v.to_i * 3600) unless v.to_i == 0}
-        opts.define_tail ""
-        opts.define_tail ""
-      end
+    def validate_options
+      abort "You must specify at least one graphite host" if options[:backends].empty?
     end
 
   end
-end
+end

data/lib/graphite-api/scheduler.rb

@@ -14,7 +14,7 @@ module GraphiteAPI
       end
 
       def stop
-        timers.map(&:cancel)
+        timers.map {|t| t.cancel}
         wrapper and EventMachine.stop
       end
 

data/lib/graphite-api/utils.rb

@@ -1,20 +1,26 @@
 module GraphiteAPI
   module Utils
+    
     module_function
 
     def normalize_time(time,slice = 60)
       ((time || Time.now).to_i / slice * slice).to_i
     end
-    
+ 
+    def expand_host host
+      host,port = host.split(":")
+      port = port.nil? ? default_options[:port] : port.to_i
+      [host,port]
+    end
+
     def default_options
       {
+        :backends => [],
         :cleaner_interval => 43200,
-        :graphite_port => 2003,
-        :listening_port => 2003,
+        :port => 2003,
         :log_level => :info,
         :cache_exp => nil,
         :host => "localhost",
-        :port => 2003,
         :prefix => [],
         :interval => 60,
         :slice => 60,
@@ -22,5 +28,20 @@ module GraphiteAPI
       }
     end
     
+    def daemonize pid
+      block_given? or raise ArgumentError.new "the block is missing..."
+      fork do
+        Process.setsid
+        exit if fork
+        Dir.chdir '/tmp'
+        STDIN.reopen('/dev/null')
+        STDOUT.reopen('/dev/null','a')
+        STDERR.reopen('/dev/null','a')
+        File.open(pid,'w') { |f| f.write(Process.pid) } rescue
+        yield
+      end
+
+    end
+
   end
 end

data/lib/graphite-api/version.rb

@@ -1,22 +1,5 @@
 module GraphiteAPI
   class Version
-    PFILE = File.join(GraphiteAPI::ROOT,"..",".pre_version")
-    class << self
-      def string
-        [0,0,0,pre].join(".")
-      end
-
-      def increment_pre
-        new_version = pre + 1
-        File.open(PFILE,"w") { |f| f.puts new_version }
-      end
-
-      private
-      def pre
-        File.read(PFILE).to_i
-      end
-      
-    end
-    
+    VERSION = "0.0.0.24"
   end
 end

data/tasks/build.rake

@@ -27,23 +27,4 @@ end
 task :install => [:gem] do
    sh "gem install pkg/graphite-api"
    Rake::Task['clobber_package'].execute
-end
-
-namespace :gem do
-  desc "Update GraphiteAPI gem version"
-  task :update_version do
-    GraphiteAPI::Version.increment_pre
-    msg "Incrementing version to #{GraphiteAPI::Version.string}..."
-  end
-  
-  desc "Upload GraphiteAPI to rubygems.org"
-  task :upload => [:build] do
-    sh "gem push pkg/graphite-api-#{GraphiteAPI.version}.gem"
-  end
-  
-  desc "Update GraphiteAPI gem version and build gem"
-  task :build => [:test,:update_version] do
-    sh "rake gem"
-  end 
-  
-end
+end

data/tasks/tests.rake

@@ -1,3 +1,8 @@
-task :test do
-  # tests here
-end
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "tests"
+  t.pattern = "tests/**/*_test.rb"
+end
+
+task :default => :test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphite-api
 version: !ruby/object:Gem::Version
-  version: 0.0.0.23
+  version: 0.0.0.24
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-17 00:00:00.000000000Z
+date: 2012-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2152423400 !ruby/object:Gem::Requirement
+  requirement: &70342798606180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: 0.3.3
   type: :runtime
   prerelease: false
-  version_requirements: *2152423400
+  version_requirements: *70342798606180
 description: Graphite API - A Simple ruby client, aggregator daemon and API tools
 email: eran@kontera.com
 executables:
@@ -33,8 +33,10 @@ files:
 - Rakefile
 - bin/graphite-middleware
 - lib/graphite-api/buffer.rb
+- lib/graphite-api/cli.rb
 - lib/graphite-api/client.rb
 - lib/graphite-api/connector.rb
+- lib/graphite-api/connector_group.rb
 - lib/graphite-api/logger.rb
 - lib/graphite-api/middleware.rb
 - lib/graphite-api/runner.rb
@@ -64,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: graphite-api
-rubygems_version: 1.8.17
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Graphite Ruby Client