quark 0.0.1

data/bin/quark

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'quark'
+require 'quark/config'
+
+module Quark
+  class CLI
+    class<<self
+      def run()
+        @options = {}
+
+        (OptionParser.new do |opts|
+          opts.banner = "Usage: quark [options]"
+
+        # -----------------------------------------------------------------------------
+          opts.on('-H', '--redis-host HOST', 'Hostname of the Redis server to write to') do |host|
+            Quark::Config.set("redis.host", host)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-P', '--redis-port PORT', 'Hostname of the Redis server to write to') do |port|
+            Quark::Config.set("redis.port", port)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-N', '--redis-prefix PREFIX', 'The string used to prefix keys in Redis') do |prefix|
+            Quark::Config.set("redis.prefix", prefix)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-S', '--socket FILE', 'Location of the Unix socket to accept commands from') do |file|
+            Quark::Config.set("quark.socket", file)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-a', '--listen-address ADDR', 'The IP address to listen on') do |addr|
+            Quark::Config.set("quark.address", addr)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-p', '--listen-port PORT', 'The TCP port to listen on') do |port|
+            Quark::Config.set("quark.port", port)
+          end
+
+        end).parse!
+
+        Quark::Server.run()
+      end
+    end
+  end
+end
+
+Quark::CLI.run()

data/lib/quark.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+require 'eventmachine'
+require 'redis'
+require 'hiredis'
+require 'em-synchrony'
+require 'multi_json'
+require 'quark/config'
+
+
+module Quark
+  module SocketServer
+    Dir[File.join(File.dirname(__FILE__), "quark", "commands", "*.rb")].each do |rb|
+      require "#{rb.gsub(/\.rb$/,'')}"
+    end
+
+    def post_init()
+      @redis = Redis.new({
+        :host => Quark::Config.get("redis.host", "127.0.0.1"),
+        :port => Quark::Config.get("redis.port", 6379).to_i,
+        :db   => Quark::Config.get("redis.db", 0).to_i
+      })
+
+      @_prefix = Quark::Config.get("redis.prefix", "quark")
+    end
+
+    def receive_data(data)
+      command, arguments = data.chomp.split(' ',2)
+
+      if methods.include?(:"process_command_#{command.downcase}")
+        rv = send(:"process_command_#{command.downcase}", arguments)
+        if rv.nil?
+          send_data(MultiJson.dump({
+            :success => true
+          })+"\n")
+        else
+          send_data(MultiJson.dump({
+            :success => true,
+            :command => data.chomp,
+            :results => rv
+          })+"\n")
+        end
+      end
+    end
+
+    def unbind()
+    end
+  end
+
+  class Server
+    def self.run()
+      @address  = Quark::Config.get("quark.address", "127.0.0.1")
+      @port     = Quark::Config.get("quark.port",    12161)
+      @filename = Quark::Config.get("quark.socket")
+
+      EM.run do
+        if not @filename.nil? and File.writable?(File.dirname(@filename))
+          puts "Starting server at #{@filename}..."
+          EM::start_server(@filename, Quark::SocketServer)
+        else
+          puts "Starting server on #{@address}:#{@port}..."
+          EM::start_server(@address, @port, Quark::SocketServer)
+        end
+      end
+    end
+  end
+end

data/lib/quark/commands/fetch.rb

@@ -0,0 +1,45 @@
+module Quark
+  module SocketServer
+    def process_command_fetch(data)
+      rv = {}
+      keys, from, to = data.split(' ')
+      now = (Time.now.to_f * 1000).to_i
+
+    # negative from/to values are treated as relative number of seconds from now
+      if from.to_i < 0
+        from = (now - (-1 * from.to_i * 1000))
+      end
+
+      if to.to_i < 0
+        to = (now - (-1 * to.to_i * 1000))
+      end
+
+    # if not set, to defaults to now
+      to ||= now
+
+    # find all matching keys from all blocks
+      @redis.keys("#{@_prefix}:#{keys}:*").each do |key|
+        x, name, block = key.split(':',3)
+        block = block.to_i
+
+      # skip keys whose block falls outside of the given time range (if given)
+        next if block > 0 and not from.nil? and block < (from.to_i/1000/3600).to_i
+        next if block > 0 and not to.nil?   and block > (to.to_i/1000/3600).to_i
+
+      # get all values, sort by timestamp ascending, and append to ouput (within range, if given)
+        @redis.hgetall(key).sort{|a,b|
+          a[0] <=> b[0]
+        }.each do |timestamp, value|
+          timestamp = timestamp.to_i
+
+          if timestamp >= from.to_i and timestamp <= to.to_i
+            rv[name] ||= []
+            rv[name] << [timestamp, value.to_f]
+          end
+        end
+      end
+
+      return rv
+    end
+  end
+end

data/lib/quark/commands/observe.rb

@@ -0,0 +1,11 @@
+module Quark
+  module SocketServer
+    def process_command_observe(data)
+      id, value, timestamp = data.chomp.split(' ')
+      block = Integer(timestamp.to_i / 1000 / 3600)
+
+      @redis.hset("#{@_prefix}:#{id}:#{block}", timestamp, value)
+      return nil
+    end
+  end
+end

data/lib/quark/commands/peek.rb

@@ -0,0 +1,28 @@
+module Quark
+  module SocketServer
+    def process_command_peek(data)
+      rv = {}
+      keys = @redis.keys("#{@_prefix}:#{data}:*")
+      peek_keys = []
+
+    # get unique metric names
+      keys.collect{|i|
+        i.split(':')[1]
+      }.uniq().each do |name|
+      # get most recent bucket for this metric
+        peek_keys << keys.select{|i|
+          i.split(':')[1] == name
+        }.sort.last
+      end
+
+    # now that we have the most recent bucket, pull the most recent value from that bucket
+      peek_keys.each do |peek|
+        rv[peek.split(':')[1]] = @redis.hgetall(peek).sort{|a,b|
+          a[0] <=> b[0]
+        }.last
+      end
+
+      return rv
+    end
+  end
+end

data/lib/quark/config.rb

@@ -0,0 +1,18 @@
+module Quark
+  class Config
+    require 'hashlib'
+    @_options = Hash.new()
+
+    def self.get(key, fallback=nil)
+      @_options.rget(key, fallback)
+    end
+
+    def self.set(key, value)
+      @_options.rset(key, value)
+    end
+
+    def self.all()
+      @_options
+    end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: quark
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gary Hetzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &14255880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.7.9
+  type: :runtime
+  prerelease: false
+  version_requirements: *14255880
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &14253980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *14253980
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &14252900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *14252900
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: &14251500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *14251500
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: &14265760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *14265760
+description: A small service for logging and retrieving timeseries metrics into a
+  Redis server
+email: garyhetzel@gmail.com
+executables:
+- quark
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/quark.rb
+- lib/quark/config.rb
+- lib/quark/commands/peek.rb
+- lib/quark/commands/fetch.rb
+- lib/quark/commands/observe.rb
+- bin/quark
+homepage: https://github.com/ghetzel/quark
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A miniscule timeseries metrics logging service
+test_files: []