graphite-api 0.0.1.4 → 0.0.2.0

data/README.md

@@ -2,50 +2,90 @@
 A Ruby API toolkit for [Graphite](http://graphite.wikidot.com/).
 
 ## Description
-Graphite client and utilities for ruby
+**GraphiteAPI** is a library written in Ruby that provides two ways for interacting with **Graphite's Carbon Daemon**, the first is for Ruby applications using the **GraphiteAPI::Client**, the second is through **GraphiteAPI-Middleware** daemon, both methods implements Graphite's [plaintext protocol](http://graphite.readthedocs.org/en/1.0/feeding-carbon.html).
 
-* **Simple** client for ruby.
+## Package Content
+* Includes a **simple** client for ruby.
 * 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 aggregated data to multiple graphite servers, useful for large data centers and backup purposes
-* Reanimation mode - support cases which the same keys (same timestamps as well) can be received simultaneously and asynchronously from multiple input sources, in these cases GraphiteAPI-Middleware will "reanimate" old records (records that were already sent to Graphite server), and will send the sum of the reanimated record value + the value of the record that was just received to the graphite server; this new summed record should override the key with the new value on Graphite database.
+## Key Features
+* **Multiple Graphite Servers Support** - GraphiteAPI-Middleware supports sending aggregated data to multiple graphite servers, useful for large data centers and backup purposes
+* **Reanimation mode** - support cases which the same keys (same timestamps as well) can be received simultaneously and asynchronously from multiple input sources, in these cases GraphiteAPI-Middleware will "reanimate" old records (records that were already sent to Graphite server), and will send the sum of the reanimated record value + the value of the record that was just received to the graphite server; this new summed record should override the key with the new value on Graphite database.
+
+## Installation
+Install stable version
+
+```
+gem install graphite-api
+```
+
+Install the latest from github
+
+```
+git clone git://github.com/kontera-technologies/graphite-api.git
+cd graphite-api
+rake install
+```
 
 ## Client Usage
 ```ruby
- 	require 'graphite-api'
-
- 	client = GraphiteAPI::Client.new(
-	 :graphite => "graphite.example.com:2003",
- 	 :prefix => ["example","prefix"], # add example.prefix to each key
- 	 :interval => 60                  # send to graphite every 60 seconds
- 	)
-    
- 	# Simple:
- 	client.metrics("webServer.web01.loadAvg" => 10.7)
- 	# => example.prefix.webServer.web01.loadAvg 10.7 time.now.stamp
-	
- 	# Multiple with time:
- 	client.metrics({
- 		"webServer.web01.loadAvg" => 10.7,
- 		"webServer.web01.memUsage" => 40
- 	},Time.at(1326067060))
- 	# => example.prefix.webServer.web01.loadAvg  10.7 1326067060
- 	# => example.prefix.webServer.web01.memUsage 40 1326067060
- 	
- 	# Every 10 sec
- 	client.every(10) do
- 	  client.metrics("webServer.web01.uptime" => `uptime`.split.first.to_i) 
- 	end
-	
- 	client.join # wait...
+  require 'graphite-api'
+  require 'logger'
+  
+  # Turn on the logging ( optional )
+  GraphiteAPI::Logger.logger = ::Logger.new(STDOUT)
+  GraphiteAPI::Logger.logger.level = ::Logger::DEBUG
+  
+  # Setup client
+  client = GraphiteAPI::Client.new(  
+   :graphite => "graphite.example.com:2003",
+   :prefix   => ["example","prefix"], # add example.prefix to each key
+   :slice    => 60.seconds            # results are aggregated in 60 seconds slices
+   :interval => 60.seconds            # send to graphite every 60 seconds
+  )
+  
+  # Simple
+  client.webServer.web01.loadAvg 10.7 
+  # => example.prefix.webServer.web01.loadAvg 10.7 time.now.to_i
+  
+  # "Same Same But Different" ( http://en.wikipedia.org/wiki/Tinglish )
+  client.metrics "webServer.web01.loadAvg" => 10.7
+  # => example.prefix.webServer.web01.loadAvg 10.7 time.now.to_i
+  
+  # With event time
+  client.webServer.web01.blaBlaBla(29.1, Time.at(9999999999))
+  # => example.prefix.webServer.web01.blaBlaBla 29.1 9999999999
+  
+  # Multiple with event time
+  client.metrics({
+    "webServer.web01.loadAvg"  => 10.7,
+    "webServer.web01.memUsage" => 40
+  },Time.at(1326067060))
+  # => example.prefix.webServer.web01.loadAvg  10.7 1326067060
+  # => example.prefix.webServer.web01.memUsage 40 1326067060
+  
+  # Timers
+  client.every 10.seconds do |c|
+    c.webServer.web01.uptime `uptime`.split.first.to_i
+    # => example.prefix.webServer.web01.uptime 40 1326067060
+  end
+  
+  client.every 52.minutes do |c|
+    c.abcd.efghi.jklmnop.qrst 12 
+    # => example.prefix.abcd.efghi.jklmnop.qrst 12 1326067060
+  end
+  
+  client.join # wait...
 ```	
+> more examples can be found [here](https://github.com/kontera-technologies/graphite-api/tree/master/examples).
+
 ## GraphiteAPI-Middleware Usage
+* After installing GraphiteAPI gem, the `graphite-middleware` command should be available.
 
 ```
-[root@someplace]# graphite-middleware --help
+[root@graphite-middleware-node]# graphite-middleware --help
 
 GraphiteAPI Middleware Server
 
@@ -63,21 +103,57 @@ Usage: graphite-middleware [options]
 More Info @ https://github.com/kontera-technologies/graphite-api
 ```
 
-## Installation
-Install stable version
+* launch **GraphiteAPI-Middleware** daemon
 
 ```
-gem install graphite-api
+[root@graphite-middleware-node]# graphite-middleware              \
+  --port 2005                                                     \
+  --interval 60                                                   \
+  --log-level debug                                               \
+  --log-file /tmp/graphite-middleware.out                         \
+  --daemonize                                                     \
+  --graphite graphite-server:2003                                 \
+  --graphite graphite-backup-server:2003   
 ```
 
-Install the latest from github
+* Send metrics via **UDP/TCP sockets**
 
 ```
-git clone git://github.com/kontera-technologies/graphite-api.git
-cd graphite-api
-rake install
+[root@graphite-middleware-node] telnet localhost 2005
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+example.middleware.value 10.2 1335008343
+example.middleware.value2 99 1334929231
+^C
+[root@graphite-middleware-node]
 ```
 
+* Send metrics via **GraphtieAPI client**
+
+```ruby
+require 'graphite-api'
+client = GraphiteAPI::Client.new(:graphite => graphite-middleware-node)
+client.example.middleware.value 10.2 
+client.example.middleware.value2 27
+client.bla.bla.value2 27
+```
+
+> more examples can be found [here](https://github.com/kontera-technologies/graphite-api/tree/master/examples).
+
+
+## Recommended Topologies
+<br/>
+
+<img src="https://raw.github.com/kontera-technologies/graphite-api/master/examples/graphite-middleware-star.jpg" align="center">
+
+<hr/>
+<br/>
+
+<img src="https://raw.github.com/kontera-technologies/graphite-api/master/examples/graphite-middleware-mesh.jpg" align="center">
+
+<hr/>
+
 ## TODO:
 * Documentation
 * Use Redis

data/lib/core-extensions/numeric.rb

@@ -0,0 +1,20 @@
+class Numeric
+  {
+    :year   => 365 * 24 * 3600,
+    :month  => 30 * 24 * 3600,
+    :week   => 7 * 24 * 3600,
+    :day    => 24 * 3600,
+    :hour   => 3600,
+    :minute => 60,
+    :second => 1
+  }.each do |m,val|
+      respond_to? m or define_method m do 
+        self * val
+      end
+      
+      "#{m}s".tap do |plural|
+        respond_to? plural or alias_method plural, m
+      end
+
+    end    
+end

data/lib/graphite-api.rb

@@ -17,4 +17,5 @@ module GraphiteAPI
     GraphiteAPI::Version::VERSION
   end
   
+  Dir.glob( "#{ROOT}/core-extensions/**" ).each &method( :require )
 end

data/lib/graphite-api/buffer.rb

@@ -23,7 +23,7 @@ module GraphiteAPI
     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"                     # skip these chars when parsing new message
+    CHARS_TO_IGNORE     = ["\r"]                   # skip these chars when parsing new message
     FLOATS_ROUND_BY = 2                            # round(x) after summing floats 
     VALID_MESSAGE = /^[\w|\.]+ \d+(?:\.|\d)* \d+$/ # how a valid message should look like
     
@@ -36,30 +36,37 @@ module GraphiteAPI
     end
 
     def push hash
-      debug [:buffer,:add,hash]
-      time = Utils::normalize_time(hash[:time],options[:slice])
+      debug [:buffer,:add, hash]
+      time = Utils.normalize_time(hash[:time],options[:slice])
       hash[:metric].each { |k,v| cache_set(time,k,v) }
     end
 
-    alias :<< :push
+    alias_method :<<, :push
     
     def stream message, client_id = nil
       message.each_char do |char|
         next if invalid_char? char
-        streamer_buff[client_id] << char 
+        streamer_buff[client_id] += char 
         
         if closed_stream? streamer_buff[client_id]
-          push build_metric(*streamer_buff[client_id].split) if valid streamer_buff[client_id]
+          if valid streamer_buff[client_id]
+            push build_metric *streamer_buff[client_id].split
+          end
           streamer_buff.delete client_id
         end
-        
       end
     end
     
-    def pull(as = nil)
-      [].tap do |data|
-        keys_to_send.each { |t, k| k.each { |o| data.push cache_get(t, o, as) } } and clear
+    def pull as = nil
+      Array.new.tap do |data|
+        keys_to_send.each do |time,keys|
+          keys.each do |key|
+            data.push cache_get(time, key, as)
+          end
+        end
+        clear
       end
+      
     end
     
     def new_records?
@@ -67,21 +74,22 @@ module GraphiteAPI
     end
     
     private
+    
     def closed_stream? string
       string[-1,1] == CLOSING_STREAM_CHAR
     end
     
     def invalid_char? char
-      IGNORING_CHARS.include? char
+      CHARS_TO_IGNORE.include? char
     end
     
     def cache_set time, key, value
-      buffer_cache[time][key] = sum(buffer_cache[time][key],value.to_f)
-      keys_to_send[time].push(key) unless keys_to_send[time].include?(key)
+      buffer_cache[time][key] = sum buffer_cache[time][key], value.to_f 
+      keys_to_send[time].push key unless keys_to_send[time].include? key
     end
     
     def sum float1, float2
-      ("%.#{FLOATS_ROUND_BY}f" % (float1 + float2)).to_f # can't use round on 1.8.7
+      ("%.#{FLOATS_ROUND_BY}f" % (float1 + float2)).to_f # can't use round on 1.8.X
     end
         
     def cache_get time, key, as

data/lib/graphite-api/cli.rb

@@ -1,4 +1,5 @@
 require 'optparse'
+
 module GraphiteAPI
   class CLI
     

data/lib/graphite-api/client.rb

@@ -4,83 +4,120 @@
 # -----------------------------------------------------
 # Usage
 #
-#  client = GraphiteAPI::Client.new(
-#    :graphite => "graphite.example.com:2003",
-#    :prefix => ["example","prefix"], # add example.prefix to each key
-#    :interval => 60                  # send to graphite every 60 seconds
-#    )
+#  client = GraphiteAPI::Client.new(  
+#   :graphite => "graphite.example.com:2003",
+#   :prefix   => ["example","prefix"], # add example.prefix to each key
+#   :slice    => 60.seconds            # results are aggregated in 60 seconds slices
+#   :interval => 60.seconds            # send to graphite every 60 seconds
+#  )
 #  
-#  # Simple:
-#  client.metrics("webServer.web01.loadAvg" => 10.7)
-#  # => example.prefix.webServer.web01.loadAvg 10.7 time.now.stamp
+#  # Simple
+#  client.webServer.web01.loadAvg 10.7 
+#  # => example.prefix.webServer.web01.loadAvg 10.7 time.now.to_i
+
+#  # "Same Same But Different" ( http://en.wikipedia.org/wiki/Tinglish )
+#  client.metrics "webServer.web01.loadAvg" => 10.7
+#  # => example.prefix.webServer.web01.loadAvg 10.7 time.now.to_i
 #  
-#  # Multiple with time:
+#  # Multiple with event time
 #  client.metrics({
-#	  "webServer.web01.loadAvg" => 10.7,
-#	  "webServer.web01.memUsage" => 40
+#   "webServer.web01.loadAvg"  => 10.7,
+#   "webServer.web01.memUsage" => 40
 #  },Time.at(1326067060))
 #  # => example.prefix.webServer.web01.loadAvg  10.7 1326067060
 #  # => example.prefix.webServer.web01.memUsage 40 1326067060
-#  
-#  # Every 10 sec
-#  client.every(10) do
-#    client.metrics("webServer.web01.uptime" => `uptime`.split.first.to_i) 
-#  end
-#  
-#  client.join # wait...
+# 
+#  #  Timers
+# client.every 10.seconds do |c|
+#   c.webServer.web01.uptime `uptime`.split.first.to_i
+#   # => example.prefix.webServer.web01.uptime 40 1326067060
+# end
+# 
+# client.every 52.minutes do |c|
+#   c.abcd.efghi.jklmnop.qrst 12 
+#   # => example.prefix.abcd.efghi.jklmnop.qrst 12 1326067060
+# end
+# 
+# client.join # wait...
 # -----------------------------------------------------
+
+require File.expand_path '../utils', __FILE__
+
 module GraphiteAPI
   class Client
     include Utils
     
-    attr_reader :options,:buffer,:connectors
-    
+    extend Utils::ClassMethods
+      
     def initialize opt
-      @options    = build_options(validate(opt.clone))
-      @buffer     = GraphiteAPI::Buffer.new(options)
-      @connectors = GraphiteAPI::ConnectorGroup.new(options)
-      start_scheduler
+      @options = build_options validate opt.clone
+      @buffer  = GraphiteAPI::Buffer.new options
+      @connectors = GraphiteAPI::ConnectorGroup.new options
+      
+      every options.fetch :interval do
+        connectors.publish buffer.pull :string if buffer.new_records?
+      end
+      
     end
 
-    def add_metrics(m,time = Time.now)
-      buffer.push(:metric => m, :time => time)
-    end
-    alias :metrics :add_metrics
+    attr_private_reader :options, :buffer, :connectors
+    delegate :loop, :stop, :to => :Reactor
     
-    def join
-      sleep 0.1 while buffer.new_records?
+    def every interval, &block
+      Reactor.every interval do 
+        block.call self
+      end
     end
     
-    def loop
-      Reactor.loop
+    def metrics metric, time = Time.now 
+      buffer.push :metric => metric, :time => time
     end
-    
-    def stop
-      Reactor.stop
+
+    def join
+      sleep while buffer.new_records?
     end
     
-    def every(frequency,&block)
-      Reactor.every(frequency,&block)
+    def method_missing m, *args, &block
+      Proxy.new( self ).send m, *args, &block
     end
-
-    protected
     
-    def start_scheduler
-      Reactor::every(options[:interval]) { send_metrics }
-    end
+    protected
     
-    def send_metrics
-      connectors.publish buffer.pull(:string) if buffer.new_records?
+    class Proxy
+      extend Utils::ClassMethods
+      
+      def initialize client
+        @client = client
+        @keys = []
+      end
+      
+      attr_private_reader :client, :keys
+      
+      def method_missing m, *args, &block
+        keys.push m
+        if keys.size > 10 # too deep
+          super
+        elsif !args.empty?
+          client.metrics(
+            Hash[keys.join("."),args.first],
+            *args[1..-1]
+          ) 
+        else
+          self
+        end
+      end
+      
     end
-    
-    def validate opt
-      raise ArgumentError.new ":graphite must be specified" if opt[:graphite].nil?
-      opt
+            
+    def validate options
+      options.tap do |opt|
+        raise ArgumentError.new ":graphite must be specified" if opt[:graphite].nil?
+      end
     end
     
     def build_options opt
       default_options.tap do |options_hash|
-        options_hash[:backends] << expand_host(opt.delete(:graphite))
+        options_hash[:backends].push expand_host opt.delete :graphite
         options_hash.merge! opt
         options_hash.freeze
       end

data/lib/graphite-api/connector.rb

@@ -15,7 +15,7 @@ module GraphiteAPI
 
     attr_reader :options, :host, :port
     
-    def initialize(host,port)
+    def initialize host, port
       @host = host
       @port = port
     end
@@ -38,7 +38,7 @@ module GraphiteAPI
     
     def socket
       if @socket.nil? || @socket.closed?
-        @socket = ::TCPSocket.new(host,port)
+        @socket = ::TCPSocket.new host, port
       end
       @socket
     end

data/lib/graphite-api/logger.rb

@@ -5,6 +5,11 @@
 #     Graphite::Logger.logger = ::Logger.new(STDOUT) 
 #     Graphite::Logger.info "shuki tuki"
 #     Graphite::Logger.debug "hihi"
+# 
+# Or:
+#     Graphite::Logger.init :level => :debug
+#     Graphite::Logger.info "shuki tuki"
+#     Graphite::Logger.debug "hihi"
 # -----------------------------------------------------
 require 'logger'
 

data/lib/graphite-api/middleware.rb

@@ -20,51 +20,60 @@
 require 'rubygems'
 require 'eventmachine'
 require 'socket'
+require File.expand_path '../utils', __FILE__
 
 module GraphiteAPI
   class Middleware < EventMachine::Connection
-    include GraphiteAPI::Utils
-    
-    attr_reader :logger,:buffer,:client_id
 
+    include Utils
+    extend  Utils::ClassMethods
+    
     def initialize buffer
-      @buffer = buffer
-      super
+      @buffer = buffer and super
     end
-
+    
+    attr_private_reader :buffer,:client_id
+    
     def post_init
-      @client_id = Socket.unpack_sockaddr_in(get_peername).reverse.join(":")
-      debug [:middleware,:connecting,client_id]
+      @client_id = peername
+      debug [:middleware, :connecting, client_id]
     end
 
     def receive_data data
-      debug [:middleware,:message,client_id,data]
+      debug [:middleware, :message, client_id, data]
       buffer.stream data, client_id
     end
 
     def unbind
-      debug [:middleware,:disconnecting,client_id]
+      debug [:middleware, :disconnecting, client_id]
     end
-
+    
+    def peername
+      port, *ip = get_peername[2,6].unpack "nC4"
+      [ip.join("."),port].join ":"
+    end
+    
+    private :peername
+    
     def self.start options
       EventMachine.run do
-        buffer = GraphiteAPI::Buffer.new(options)
-        connectors = GraphiteAPI::ConnectorGroup.new(options)
-        
-        # Starting server
-        EventMachine.start_server('0.0.0.0',options[:port],self,buffer)
         GraphiteAPI::Logger.info "Server running on port #{options[:port]}"
         
-        # Send metrics to graphite every X seconds
-        GraphiteAPI::Reactor::every( options[:interval] ) do
-          connectors.publish buffer.pull(:string) if buffer.new_records?
-        end # every 
+        buffer = GraphiteAPI::Buffer.new options
+        group  = GraphiteAPI::ConnectorGroup.new options
         
-        GraphiteAPI::Reactor::add_shutdown_hook do           
-          connectors.publish buffer.pull(:string)
+        # Starting server
+        [:start_server, :open_datagram_socket].each do |m|
+          EventMachine.send(m,'0.0.0.0',options[:port],self,buffer)
         end
-        
-      end # run 
+
+        # Send metrics to graphite every X seconds
+        proc { group.publish buffer.pull :string if buffer.new_records? }.tap do |block|
+          GraphiteAPI::Reactor.every options[:interval], &block
+          GraphiteAPI::Reactor.add_shutdown_hook &block
+        end
+      end
+      
     end # start
   end # Middleware
 end # GraphiteAPI

data/lib/graphite-api/reactor.rb

@@ -8,7 +8,7 @@ module GraphiteAPI
     class << self
       def every(frequency,&block)
         reactor_running? or start_reactor
-        timers << EventMachine::PeriodicTimer.new(frequency) { yield }
+        timers << EventMachine::PeriodicTimer.new(frequency.to_i) { yield }
         timers.last
       end
 

data/lib/graphite-api/runner.rb

@@ -4,29 +4,29 @@ module GraphiteAPI
   class Runner
     include Utils
     
-    def initialize(argv)
-      GraphiteAPI::CLI::parse(argv,options)
+    def initialize argv
+      CLI.parse argv, options
       validate_options
     end
     
     def run
+      Logger.init Hash[[:std,:level].zip options.values_at(:log_file, :log_level) ]
       options[:daemonize] ? daemonize(options[:pid]) { run! } : run!
     end
 
     private
     
     def run!
-      GraphiteAPI::Logger.init(:std => options[:log_file], :level => options[:log_level])
       begin
-        Middleware::start options
+        Middleware.start options
       rescue Interrupt
-        GraphiteAPI::Logger.info "Shutting down..."
-        GraphiteAPI::Reactor::stop
+        Logger.info "Shutting down..."
+        Reactor.stop
       end
     end
 
     def options
-      @options ||= Utils::default_options
+      @options ||= Utils.default_options
     end
 
     def validate_options

data/lib/graphite-api/utils.rb

@@ -1,5 +1,26 @@
 module GraphiteAPI
   module Utils
+    module ClassMethods
+      def attr_private_reader *args
+        args.each { |o| attr_reader o or private o }
+      end
+
+      def delegate *sources, options
+        instance_eval do
+          options.fetch(:to).tap do |target|
+            sources.each do |source|
+              define_method source do |*args, &block|
+                if target.is_a? Symbol
+                  eval String target 
+                else
+                  target
+                end.send source,*args, &block
+              end # define
+            end # sources
+          end # options
+        end # instance_eval
+      end # def delegate
+    end # ClassMethods
     
     [:info,:error,:warn,:debug].each do |m|
       define_method(m) do |*args,&block|
@@ -9,7 +30,7 @@ module GraphiteAPI
     
     module_function
 
-    def normalize_time(time,slice = 60)
+    def normalize_time time, slice = 60
       ((time || Time.now).to_i / slice * slice).to_i
     end
  
@@ -30,12 +51,13 @@ module GraphiteAPI
         :prefix => [],
         :interval => 60,
         :slice => 60,
-        :pid => "/var/run/graphite-middleware.pid"
+        :pid => "/tmp/graphite-middleware.pid"
       }
     end
     
     def daemonize pid
       block_given? or raise ArgumentError.new "the block is missing..."
+
       fork do
         Process.setsid
         exit if fork
@@ -43,10 +65,10 @@ module GraphiteAPI
         STDIN.reopen('/dev/null')
         STDOUT.reopen('/dev/null','a')
         STDERR.reopen('/dev/null','a')
-        File.open(pid,'w') { |f| f.write(Process.pid) } rescue
+        File.open(pid,'w') { |f| f.write(Process.pid) } rescue nil
         yield
       end
     end
-   
+
   end
 end

data/lib/graphite-api/version.rb

@@ -1,5 +1,5 @@
 module GraphiteAPI
   class Version
-    VERSION = "0.0.1.4"
+    VERSION = "0.0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphite-api
 version: !ruby/object:Gem::Version
-  version: 0.0.1.4
+  version: 0.0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-30 00:00:00.000000000 Z
+date: 2012-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &70249458332220 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,12 @@ dependencies:
         version: 0.3.3
   type: :runtime
   prerelease: false
-  version_requirements: *70249458332220
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.3
 description: Graphite API - A Simple ruby client, aggregator daemon and API tools
 email: eran@kontera.com
 executables:
@@ -32,6 +37,7 @@ files:
 - README.md
 - Rakefile
 - bin/graphite-middleware
+- lib/core-extensions/numeric.rb
 - lib/graphite-api/buffer.rb
 - lib/graphite-api/cli.rb
 - lib/graphite-api/client.rb
@@ -66,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: graphite-api
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Graphite Ruby Client