graphite-api 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3795d731081bacee9b35120d168a33510344cfb
-  data.tar.gz: 7ca9645cdc7ba74fd7d4cd0c9acca2339d08ff51
+  metadata.gz: e7f26c3b31d445c4e11d556609f0c3b600c60fe7
+  data.tar.gz: 657df67acbef98202c7278e473994b4bd47841f9
 SHA512:
-  metadata.gz: c406a9bd20f842267022b51ce627e30850f1ccf1fbc35b49ac7522a02a1e6b64c3f6ca7e514287c5ddd053985ef1d2f5aa89cc3c616b2378213d4c90b1c1212a
-  data.tar.gz: 34d55c38be10cefbaa253889d6294941116612857a404145ae17bb1ba447149f381d0eef336bc999b046afd3cd04da4f3201ad563d2968917ae91b2db4762658
+  metadata.gz: 4e464886000e85f88d21dd6351d60e3160a3dc9b4e66b4d98f72f7fd3ae1f50556494843c21b3430d1d26aa11ed2c7c9d23dcf36bd8b7177a1dc804e07811d91
+  data.tar.gz: 8cba41ac302987b045af13b8ef025ff08b9c93e49353442e38edbd7b8db66ec70c4f538ec4f6aff4d125e2f777972aef5bc1b7b5a20b2104863e1803573e183a

data/README.md

@@ -1,13 +1,9 @@
-# GraphiteAPI
-A Ruby API toolkit for [Graphite](http://graphite.wikidot.com/).
-
-## Description
+# Description
 **GraphiteAPI** 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).
 
 ## Package Content
 * Includes a **simple** client for ruby.
 * Ships with a **GraphiteAPI-Middleware**, which is a lightweight, event-driven, aggregator daemon.
-* Only one gem dependency ( EventMachine ).
 * Utilities like scheduling and caching.
 
 ## Key Features
@@ -51,12 +47,12 @@ Creating a new client instance
 require 'graphite-api'
 
 GraphiteAPI.new(
-  graphite: "graphite.example.com:2003", # required argument
-  prefix: ["example","prefix"],          # add example.prefix to each key
-  slice: 60,                             # results are aggregated in 60 seconds slices
-  interval: 60,                          # send to graphite every 60 seconds
-                                         # default is 0 ( direct send )
-  cache: 4 * 60 * 60                     # set the max age in seconds for records reanimation
+  graphite: "udp://graphite.example.com:2003", # required argument
+  prefix: ["example","prefix"],                # add example.prefix to each key
+  slice: 60,                                   # results are aggregated in 60 seconds slices
+  interval: 60,                                # send to graphite every 60 seconds
+                                               # default is 0 ( direct send )
+  cache: 4 * 60 * 60                           # set the max age in seconds for records reanimation
 )
 ```
 
@@ -64,7 +60,7 @@ Adding simple metrics
 ```ruby
 require 'graphite-api'
 
-client = GraphiteAPI.new( graphite: 'graphite:2003' )
+client = GraphiteAPI.new( graphite: 'tcp://graphite:2003' )
 
 client.metrics "webServer.web01.loadAvg" => 10.7
 # => webServer.web01.loadAvg 10.7 time.now.to_i
@@ -81,7 +77,7 @@ Adding metrics with timestamp
 ```ruby
 require 'graphite-api'
 
-client = GraphiteAPI.new( graphite: 'graphite:2003' )
+client = GraphiteAPI.new( graphite: 'udp://graphite:2003' )
 
 client.metrics({
   "webServer.web01.loadAvg"  => 10.7,
@@ -95,7 +91,7 @@ Increment records
 ```ruby
 require 'graphite-api'
 
-client = GraphiteAPI.new( graphite: 'graphite:2003' )
+client = GraphiteAPI.new( graphite: 'tcp://graphite:2003' )
 
 client.increment("jobs_in_queue", "num_errors")
 # => jobs_in_queue 1 Time.now.to_i
@@ -115,7 +111,7 @@ Built-in timers support
 ```ruby
 require 'graphite-api'
 
-client = GraphiteAPI.new( graphite: 'graphite:2003' )
+client = GraphiteAPI.new( graphite: 'tcp://graphite:2003' )
 
 # lets send the metric every 120 seconds
 client.every(120) do |c|
@@ -128,7 +124,7 @@ Built-in extension for time declarations stuff, like 2.minutes, 3.hours etc...
 require 'graphite-api'
 require 'graphite-api/core_ext/numeric'
 
-client = GraphiteAPI.new( graphite: 'graphite:2003' )
+client = GraphiteAPI.new( graphite: 'udp://graphite:2003' )
 
 client.every 10.seconds do |c|
   c.metrics("webServer.web01.uptime" => `uptime`.split.first.to_i)
@@ -144,7 +140,7 @@ Make your own custom metrics daemons, using `client#join`
 require 'graphite-api'
 require 'graphite-api/core_ext/numeric'
 
-client = GraphiteAPI.new( graphite: 'graphite:2003' )
+client = GraphiteAPI.new( graphite: 'udp://graphite:2003' )
 
 client.every 26.minutes do |c|
   c.metrics("webServer.shuki.stats" => 10)
@@ -220,7 +216,7 @@ example.middleware.value2 99 1334929231
 
 ```ruby
 require 'graphite-api'
-client = GraphiteAPI.new(:graphite => 'graphite-middleware-node:2005')
+client = GraphiteAPI.new(:graphite => 'tcp://graphite-middleware-node:2005')
 client.example.middleware.value 10.2 
 client.example.middleware.value2 27
 client.bla.bla.value2 27

data/bin/graphite-middleware

@@ -2,5 +2,72 @@
 $:.unshift File.expand_path('../../lib',__FILE__)
 
 require 'graphite-api'
+require 'optparse'
 
-GraphiteAPI::Runner.new(ARGV).run
+options = GraphiteAPI::Client.default_options.merge interval: 60
+
+OptionParser.new do |opts|
+  opts.banner = "GraphiteAPI Middleware Server"
+  opts.define_head "Usage: graphite-middleware [options]"
+  opts.define_head ""
+
+  opts.on("-g", "--graphite [udp,tcp]://host:port", "can be specified multiple times") do |graphite|
+    options[:backends].push 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[:cache] = exp.to_i * 3600) if exp.to_i > 0
+  end
+
+  opts.on("-v", "--version","Show version and exit") do |exp|
+    puts "Version #{GraphiteAPI.version}" 
+    exit
+  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
+
+abort "You must specify at least one graphite host" if options[:backends].empty?
+
+GraphiteAPI::Logger.init Hash[[:dev,:level].zip options.values_at(:log_file, :log_level) ]
+
+begin
+  Process.daemon if options[:daemonize]
+  GraphiteAPI::Middleware.start options
+rescue Interrupt
+  GraphiteAPI::Logger.info "Shutting down..."
+  Zscheduler.stop
+end

data/lib/graphite-api.rb

@@ -1,20 +1,13 @@
 require 'zscheduler'
+require 'graphite-api/version'
+require 'graphite-api/client'
+require 'graphite-api/cache'
+require 'graphite-api/connector'
+require 'graphite-api/middleware'
+require 'graphite-api/buffer'
+require 'graphite-api/logger'
 
 module GraphiteAPI
-  ROOT = File.expand_path File.dirname __FILE__
-
-  require "#{ROOT}/graphite-api/version"
-
-  autoload :Version,    "#{ROOT}/graphite-api/version"
-  autoload :Client,     "#{ROOT}/graphite-api/client"
-  autoload :Cache,      "#{ROOT}/graphite-api/cache"
-  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"
 
   def self.version
     GraphiteAPI::VERSION

data/lib/graphite-api/buffer.rb

@@ -21,9 +21,8 @@ require 'set'
 
 module GraphiteAPI
   class Buffer
-    include Utils
     
-    CHARS_TO_BE_IGNORED = ["\r"]
+    IGNORE = ["\r"]
     END_OF_STREAM = "\n"
     VALID_MESSAGE = /^[\w|\.|-]+ \d+(?:\.|\d)* \d+$/
     
@@ -34,7 +33,7 @@ module GraphiteAPI
       @cache = Cache::Memory.new options if options[:cache]
     end
     
-    private_reader :queue, :options, :streamer, :cache
+    attr_reader :queue, :options, :streamer, :cache
     
     # this method isn't thread safe
     # use #push for multiple threads support
@@ -44,7 +43,7 @@ module GraphiteAPI
         streamer[client_id] += char 
         
         if closed_stream? streamer[client_id]
-          if valid_stream_message? streamer[client_id]
+          if streamer[client_id] =~ VALID_MESSAGE 
             push stream_message_to_obj streamer[client_id]
           end
           streamer.delete client_id
@@ -55,7 +54,7 @@ module GraphiteAPI
     # Add records to buffer
     # push({:metric => {'a' => 10},:time => Time.now})
     def push obj
-      debug [:buffer,:add, obj]
+      Logger.debug [:buffer,:add, obj]
       queue.push obj
       nil
     end
@@ -63,14 +62,13 @@ module GraphiteAPI
     alias_method :<<, :push
 
     def pull format = nil
-      data = nested_zero_hash
+      data = Hash.new {|h,k| h[k] = Hash.new {|h2,k2| h2[k2] = 0}}
 
       counter = 0
       while new_records?
         break if ( counter += 1 ) > 1_000_000 # TODO: fix this
         hash = queue.pop
-        time = normalize_time(hash[:time],options[:slice])
-        hash[:metric].each { |k,v| data[time][k] += v.to_f }
+        hash[:metric].each {|k,v| data[normalize_time(hash[:time],options[:slice])][k] += v.to_f}
       end
       
       data.map do |time, hash|
@@ -82,16 +80,21 @@ module GraphiteAPI
       end.flatten(1)
     end
     
-    def new_records?
-      !queue.empty?
-    end
-    
     def inspect
       "#<GraphiteAPI::Buffer:%s @quque#size=%s @streamer=%s>" % 
         [ object_id, queue.size, streamer]
     end
     
+    def new_records?
+      !queue.empty?
+    end
+
     private
+
+    def normalize_time time, slice
+      slice = 60 if slice.nil?
+      ((time || Time.now).to_i / slice * slice).to_i
+    end
     
     def stream_message_to_obj message
       parts = message.split
@@ -99,16 +102,12 @@ module GraphiteAPI
     end
     
     def invalid_char? char
-      CHARS_TO_BE_IGNORED.include? char
+      IGNORE.include? char
     end
     
     def closed_stream? string
       string[-1,1] == END_OF_STREAM
     end
-    
-    def valid_stream_message? message
-      message =~ VALID_MESSAGE
-    end
 
     def prefix
       @prefix ||= if options[:prefix] and !options[:prefix].empty?

data/lib/graphite-api/cache.rb

@@ -1,5 +1,35 @@
 module GraphiteAPI
   module Cache
-    autoload :Memory, File.expand_path("../cache/memory", __FILE__)
+    class Memory
+
+      def initialize options
+        Zscheduler.every(120) { clean(options[:cache]) }
+      end
+
+      def get time, key
+        cache[time.to_i][key]
+      end
+
+      def set time, key, value
+        cache[time.to_i][key] = value.to_f 
+      end
+
+      def incr time, key, value
+        set(time, key, value.to_f + get(time, key))
+      end
+
+      private
+
+      def cache
+        @cache ||= Hash.new {|h,k| h[k] = Hash.new {|h2,k2| h2[k2] = 0}}
+      end
+
+      def clean max_age
+        Logger.debug [:MemoryCache, :before_clean, cache]
+        cache.delete_if {|t,k| Time.now.to_i - t > max_age }
+        Logger.debug [:MemoryCache, :after_clean, cache]
+      end
+
+    end
   end
-end
+end

data/lib/graphite-api/client.rb

@@ -1,10 +1,13 @@
-require File.expand_path '../utils', __FILE__
-
+require 'forwardable'
+    
 module GraphiteAPI
   class Client
-    include Utils
+    extend Forwardable
 
-    private_reader :options, :buffer, :connectors
+    def_delegator Zscheduler, :loop, :join
+    def_delegator Zscheduler, :stop
+
+    attr_reader :options, :buffer, :connectors
 
     def initialize opt
       @options = build_options validate opt.clone
@@ -14,9 +17,6 @@ module GraphiteAPI
       Zscheduler.every(options[:interval]) { send_metrics } unless options[:direct]
     end
 
-    def_delegator Zscheduler, :loop, :join
-    def_delegator Zscheduler, :stop
-
     def every interval, &block
       Zscheduler.every( interval ) { block.arity == 1 ? block.call(self) : block.call }
     end
@@ -27,24 +27,12 @@ module GraphiteAPI
       send_metrics if options[:direct]
     end
 
-    alias_method :add_metrics, :metrics
-
-    # increment keys
-    #
-    # increment("key1","key2")
-    # => metrics("key1" => 1, "key2" => 1)
-    # 
-    # increment("key1","key2", {:by => 999})
-    # => metrics("key1" => 999, "key2" => 999)
-    #
-    # increment("key1","key2", {:time => Time.at(123456)})
-    # => metrics({"key1" => 1, "key2" => 1},Time.at(123456))
     def increment(*keys)
       opt = {}
       opt.merge! keys.pop if keys.last.is_a? Hash
       by = opt.fetch(:by,1)
       time = opt.fetch(:time,Time.now)
-      metric = keys.inject({}) {|h,k| h.tap { h[k] = by}}
+      metric = keys.inject({}) {|h,k| h.merge k => by }
       metrics(metric, time)
     end
 
@@ -52,6 +40,21 @@ module GraphiteAPI
       sleep while buffer.new_records?
     end
 
+    def self.default_options
+      {
+        :backends => [],
+        :cleaner_interval => 43200,
+        :port => 2003,
+        :log_level => :info,
+        :cache => nil,
+        :host => "localhost",
+        :prefix => [],
+        :interval => 0,
+        :slice => 60,
+        :pid => "/tmp/graphite-middleware.pid"
+      }
+    end
+
     protected
 
     def validate options
@@ -61,8 +64,8 @@ module GraphiteAPI
     end
 
     def build_options opt
-      default_options.tap do |options_hash|
-        options_hash[:backends].push expand_host opt.delete :graphite
+      self.class.default_options.tap do |options_hash|
+        options_hash[:backends].push opt.delete :graphite
         options_hash.merge! opt
         options_hash[:direct] = options_hash[:interval] == 0
         options_hash[:slice] = 1 if options_hash[:direct]
@@ -71,8 +74,6 @@ module GraphiteAPI
 
     def send_metrics
       connectors.publish buffer.pull :string if buffer.new_records?
-    rescue Exception => e
-      Zscheduler.init_reactor? ? raise : Logger.error("Publish Error: #{e}\n#{e.backtrace.join("\n")}")
     end
 
   end

data/lib/graphite-api/connector.rb

@@ -9,48 +9,108 @@
 # => my.metric 1092 1232123231\n
 # -----------------------------------------------------
 require 'socket'
+require 'uri'
 
 module GraphiteAPI
   class Connector
+
+    class UDPSocket
+      def initialize uri
+        @uri = uri
+        @socket = ::UDPSocket.new
+      end
+
+      def puts message
+        @socket.send message, 0, @uri.host, @uri.port
+      end
+
+      def closed?
+        @socket.closed? rescue true
+      end
+    end
+
+    class TCPSocket
+      def initialize uri
+        @uri = uri
+      end
+
+      def puts message
+        socket.puts message
+      end
+
+      def closed?
+        socket.closed? rescue true
+      end
+
+      def socket
+        @socket ||= begin
+          host, port = @uri.host, @uri.port
+          timeout = Hash[URI.decode_www_form(@uri.query.to_s)].fetch("timeout", 1)
+          addr = Socket.getaddrinfo host, nil, :INET
+          sockaddr = Socket.pack_sockaddr_in port, addr[0][3]
+
+          sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+          sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+          begin
+            sock.connect_nonblock sockaddr
+          rescue IO::WaitWritable
+            if IO.select nil, [sock], nil, timeout
+              begin
+                sock.connect_nonblock sockaddr
+              rescue Errno::EISCONN # success
+              rescue
+                sock.close
+                raise
+              end
+            else
+              sock.close
+              raise "Connection timeout"
+            end
+          end
+          sock
+        end #begin
+
+      end # Socket
+    end # TCPSocket
+
     class Group
       def initialize options
-        @connectors = options[:backends].map { |o| Connector.new(*o) }
+        @connectors = options[:backends].map(&Connector.method(:new))
       end
 
       def publish messages
-        Logger.debug [:connector_group, :publish, messages.size, @connectors]
+        Logger.debug [:connector_group, :publish, messages, @connectors]
         Array(messages).each { |msg| @connectors.map {|c| c.puts msg} }
       end
     end
-    
-    def initialize host, port
-      @host, @port = host, port
+
+    ##############################################################################
+
+    def initialize uri
+      @uri = URI.parse uri
+      @uri = @uri.host ? @uri : URI.parse("udp://#{uri}")
     end
-    
+
     def puts message
       counter = 0
       begin
-        Logger.debug [:connector,:puts,[@host, @port].join(":"),message]
+        Logger.debug [:connector, :puts, @uri, message]
         socket.puts message + "\n"
       rescue Exception
         @socket = nil
         (counter += 1) <= 5 ? retry : raise
       end
     end
-    
-    def inspect
-      "#{self.class} #{@host}:#{@port}"
-    end
-    
-    protected
-    
+
+    private 
+
     def socket
       if @socket.nil? || @socket.closed?
-        Logger.debug [:connector,[@host,@port]]
-        @socket = ::TCPSocket.new @host, @port
+        Logger.debug [:connector, :init, @uri]
+        @socket = @uri.scheme.eql?("tcp") ? TCPSocket.new(@uri) : UDPSocket.new(@uri)
       end
       @socket
     end
-     
+
   end
 end

data/lib/graphite-api/logger.rb

@@ -17,11 +17,9 @@ module GraphiteAPI
   class Logger
     class << self
       attr_accessor :logger
-      
-      # :level => :debug
-      # :dev => out|err|file-name
-      def init(options)
-        self.logger = ::Logger.new options.fetch(:dev, STDOUT)
+
+      def init options
+        self.logger = ::Logger.new options[:dev] ||  STDOUT
         self.logger.level= ::Logger.const_get options[:level].to_s.upcase
       end
       

data/lib/graphite-api/middleware.rb

@@ -16,34 +16,30 @@
 #   slice            send to graphite in X seconds slices (default is 60)
 #   log_level        info 
 # -----------------------------------------------------
-
 require 'eventmachine'
 require 'socket'
-require File.expand_path '../utils', __FILE__
 
 module GraphiteAPI
   class Middleware < EventMachine::Connection
 
-    include Utils
-    
     def initialize buffer
       @buffer = buffer and super
     end
     
-    private_reader :buffer, :client_id
+    attr_reader :buffer, :client_id
     
     def post_init
       @client_id = peername
-      debug [:middleware, :connecting, client_id]
+      Logger.debug [:middleware, :connecting, client_id]
     end
 
     def receive_data data
-      debug [:middleware, :message, client_id, data]
+      Logger.debug [:middleware, :message, client_id, data]
       buffer.stream data, client_id
     end
 
     def unbind
-      debug [:middleware, :disconnecting, client_id]
+      Logger.debug [:middleware, :disconnecting, client_id]
     end
     
     def peername
@@ -73,5 +69,5 @@ module GraphiteAPI
       end  
     end
     
-  end # Middleware
-end # GraphiteAPI
+  end 
+end 

data/lib/graphite-api/version.rb

@@ -1,3 +1,3 @@
 module GraphiteAPI
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphite-api
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Eran Barak Levi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-21 00:00:00.000000000 Z
+date: 2017-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -52,15 +52,11 @@ files:
 - lib/graphite-api.rb
 - lib/graphite-api/buffer.rb
 - lib/graphite-api/cache.rb
-- lib/graphite-api/cache/memory.rb
-- lib/graphite-api/cli.rb
 - lib/graphite-api/client.rb
 - lib/graphite-api/connector.rb
 - lib/graphite-api/core_ext/numeric.rb
 - lib/graphite-api/logger.rb
 - lib/graphite-api/middleware.rb
-- lib/graphite-api/runner.rb
-- lib/graphite-api/utils.rb
 - lib/graphite-api/version.rb
 homepage: http://www.kontera.com
 licenses:
@@ -74,7 +70,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/graphite-api/cache/memory.rb

@@ -1,36 +0,0 @@
-module GraphiteAPI
-  module Cache
-    class Memory
-      include Utils
-      
-      def initialize options
-        Zscheduler.every(120) { clean(options[:cache]) }
-      end
-      
-      def get time, key
-        cache[time.to_i][key]
-      end
-      
-      def set time, key, value
-        cache[time.to_i][key] = value.to_f 
-      end
-      
-      def incr time, key, value
-        set(time, key, value.to_f + get(time, key))
-      end
-      
-      private
-      
-      def cache
-        @cache ||= nested_zero_hash
-      end
-      
-      def clean max_age
-        debug [:MemoryCache, :before_clean, cache]
-        cache.delete_if {|t,k| Time.now.to_i - t > max_age }
-        debug [:MemoryCache, :after_clean, cache]
-      end
-      
-    end
-  end
-end

data/lib/graphite-api/cli.rb

@@ -1,63 +0,0 @@
-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[:cache] = exp.to_i * 3600) if exp.to_i > 0
-        end
-        
-        opts.on("-v", "--version","Show version and exit") do |exp|
-          puts "Version #{GraphiteAPI.version}" 
-          exit
-        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/runner.rb

@@ -1,52 +0,0 @@
-require 'optparse'
-
-module GraphiteAPI
-  class Runner
-    include Utils
-    
-    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], &method(:run!)) : run!
-    end
-
-    private
-    
-    def daemonize pid, &block
-      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 nil
-        block.call
-      end
-    end
-    
-    def run!
-      begin
-        Middleware.start options
-      rescue Interrupt
-        Logger.info "Shutting down..."
-        Zscheduler.stop
-      end
-    end
-
-    def options
-      @options ||= Utils.default_middleware_options
-    end
-
-    def validate_options
-      abort "You must specify at least one graphite host" if options[:backends].empty?
-    end
-
-  end
-end

data/lib/graphite-api/utils.rb

@@ -1,70 +0,0 @@
-require 'forwardable'
-require 'uri'
-
-module GraphiteAPI
-  module Utils
-    
-    def self.included base
-      base.extend ClassUtils
-      base.extend Forwardable
-      base.__send__ :include, LoggerUtils
-    end
-
-    module LoggerUtils
-      [:info,:error,:warn,:debug].each do |m|
-        define_method m do |*args,&block|
-          Logger.send m, *args, &block
-        end
-      end
-    end
-
-    module ClassUtils      
-      def private_reader *args
-        attr_reader *args
-        private     *args
-      end
-    end
-    
-    def normalize_time time, slice
-      slice = 60 if slice.nil?
-      ((time || Time.now).to_i / slice * slice).to_i
-    end
-    
-    def nested_zero_hash
-      Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = 0} }
-    end
-    
-    module_function
- 
-    def expand_host host
-      if host =~ /:\/\//
-        uri = URI.parse host
-        [ uri.host, uri.port || default_options[:port] ]
-      else
-        host, port = host.split(":")
-        port = port.nil? ? default_options[:port] : port.to_i
-        [ host, port]
-      end
-    end
-
-    def default_options
-      {
-        :backends => [],
-        :cleaner_interval => 43200,
-        :port => 2003,
-        :log_level => :info,
-        :cache => nil,
-        :host => "localhost",
-        :prefix => [],
-        :interval => 0,
-        :slice => 60,
-        :pid => "/tmp/graphite-middleware.pid"
-      }
-    end
-
-    def default_middleware_options
-      default_options.merge(:interval => 60)
-    end
-
-  end
-end