microphite 0.5.0

data/.gitignore

@@ -0,0 +1,13 @@
+# Editor cruft
+*~
+*.swp
+*.swo
+
+# IntelliJ
+*.iml
+/.idea
+
+# This is a library, so don't lock versions/environs
+/.ruby-gemset
+/.ruby-version
+/Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - rbx-2.1.1
+script: rake test:spec

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+Microphite CHANGELOG
+====================
+
+v0.5.0
+------
+- Initial public release.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 BZ Technology Services, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+Microphite
+==========
+
+
+Overview
+--------
+
+Microphite is a tiny and fast, asynchronous graphite client.  It can be called
+many times per second with minimal overhead (approx 6-8 microseconds per
+write/gather call on commodity hardware).  It is synchronized internally and
+can be shared across threads.
+
+
+Usage
+-----
+
+Construct a standard socket client.  See the 'Client Options' section below
+for initializer options.
+
+    client = Microphite.client(
+        host: 'graphite.blah',
+        port: 2003,
+        transport: :udp,
+        prefix: 'some.prefix')
+
+Construct a client with an error_handler.  The client is fault tolerant, but
+an error_handler is useful for logging failure events.
+
+    handler = Proc.new { |error| Rails.logger.error "Microphite error: #{error.message}" }
+    client = Microphite.client(host: '...', error_handler: handler)
+
+Construct a no-op/dummy client.  This is useful in development.  You can leave client API
+calls in-place and the dummy client will behave appropriately.
+
+    # Initializer options are accepted, but no data is written
+    client = Microphite.noop(host: 'blah', ...)
+
+Send data points
+
+    client.write('some.key': 300, 'another.key': 25)
+
+Accumulate counters (flushed every options[:flush_interval] seconds)
+
+    client.gather('some.counter': 22, 'another.counter': 10)
+
+Time a code block (results are gathered to the specified key)
+
+    client.time('app.timings.important_stuff') do
+      important_stuff()
+    end
+
+Prepend prefixes on-the-fly:
+
+    client.prefix('app.') do |app_ns|
+      # Key is prefixed with 'app.' automatically
+      app.write(key: 42)
+
+      # Nest as much as you'd like
+      app_ns.prefix('sub.') do |sub_ns|
+        # Keys prefixed by 'app.sub.'
+        sub_ns.gather(something: 5)
+      end
+    end
+
+Close the client, waiting for data to flush
+
+    client.close
+
+Alternatively, wait at most 1 second to flush
+
+    flushed = client.close(1)
+
+
+Client Options
+--------------
+
+<table>
+  <tr>
+    <th>Key</th>
+    <th>Type</th>
+    <th>Description</th>
+    <th>Default</th>
+  </tr>
+  <tr>
+    <td><tt>:host</tt></td>
+    <td>String</td>
+    <td>Graphite server host (REQUIRED)</td>
+    <td><tt>nil</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:port</tt></td>
+    <td>Integer</td>
+    <td>Graphite port</td>
+    <td><tt>2003</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:transport</tt></td>
+    <td>Symbol</td>
+    <td>Graphite transport to use (:tcp or :udp)</td>
+    <td><tt>:udp</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:prefix</tt></td>
+    <td>String/Symbol</td>
+    <td>Global prefix for all keys</td>
+    <td><tt>''</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:flush_interval</tt></td>
+    <td>Numeric</td>
+    <td>How often to flush gathered data (in seconds)</td>
+    <td><tt>10.0</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:limit</tt></td>
+    <td>Integer</td>
+    <td>Limit the write and gather stacks to this size</td>
+    <td><tt>1000000</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:min_delay</tt></td>
+    <td>Numeric</td>
+    <td>Initial delay between retry attempts after failure (in seconds)</td>
+    <td><tt>2</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:max_delay</tt></td>
+    <td>Numeric</td>
+    <td>Maximum delay between retry attempts after failure (in seconds)</td>
+    <td><tt>60</tt></td>
+  </tr>
+  <tr>
+    <td><tt>:error_handler</tt></td>
+    <td>Proc</td>
+    <td>Code block called on exception (takes a single exception param)</td>
+    <td><tt>nil</tt></td>
+  </tr>
+</table>
+
+
+License
+-------
+
+The MIT License (MIT)
+
+Copyright (c) 2013 BZ Technology Services, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+Dir['tasks/**/*.rake'].each {|f| load f}

data/lib/microphite/client/base.rb

@@ -0,0 +1,225 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+module Microphite
+  module Client
+    class Base
+      def initialize(options)
+        defaults = {
+            prefix: '',            # Prefix every key with this
+            flush_interval: 10,    # How often to flush gathered metrics
+            limit: 1000000,        # Size limit for gather and write stacks
+            error_handler: nil     # Callback block for exceptions (mainly for debug/dev)
+        }
+        params = defaults.merge(options)
+
+        # Read-only state
+        @prefix           = params[:prefix]
+        @limit            = params[:limit]
+        @flush_interval   = params[:flush_interval]
+        @error_handler    = params[:error_handler]
+
+        # Shared state
+        @status           = :running
+        @gather_stack     = []
+        @write_stack      = []
+
+        # Worker state
+        @accumulating     = {}
+        @next_flush       = now + @flush_interval
+
+        # Synchronization primitives
+        @lock             = Mutex.new
+        @worker_event     = ConditionVariable.new   # Signals worker to wake-up
+        @shutdown_event   = ConditionVariable.new   # Signals close() caller when shutdown is complete
+
+        # The worker thread does all of the data processing and socket writing
+        Thread.new do
+          wrap_errors do
+            startup
+
+            # If startup throws, then worker_loop will never be called (what we want)
+            worker_loop
+          end
+        end
+      end
+
+      def write(metrics)
+        push(@write_stack, metrics.clone)
+      end
+
+      def gather(metrics)
+        push(@gather_stack, metrics.clone)
+      end
+
+      def prefix(prefix, &block)
+        prefixed = Private::Prefixed.new(self, prefix)
+        if block_given?
+          prefixed.instance_eval &block
+        end
+        prefixed
+      end
+
+      def time(key, &block)
+        if block_given?
+          before = now
+          result = instance_eval &block
+          after = now
+          elapsed = after - before
+          gather(key => elapsed)
+          result
+        end
+      end
+
+      def close(timeout=nil)
+        @lock.synchronize do
+          case @status
+            when :running, :ending
+              @status = :ending
+              @worker_event.signal
+              @shutdown_event.wait(@lock, timeout)
+              return @status == :shutdown
+            when :shutdown
+              return true
+            else
+              error(AssertionError.new("Invalid status: #{@status}"))
+          end
+        end
+      end
+
+      protected
+
+      # Lifecycle hook for subclasses
+      def startup
+      end
+
+      # Lifecycle hook for subclasses
+      def shutdown
+      end
+
+      def write_metric(metric)
+        raise(AssertionError, 'write_metric must be implemented in subclasses')
+      end
+
+      private
+
+      def worker_loop
+        loop do
+          wrap_errors do
+            writes = nil
+            gathers = nil
+
+            @lock.synchronize do
+              if @write_stack.empty? and @gather_stack.empty?
+                case @status
+                  when :running
+                    wait_time = @next_flush - now
+                    if wait_time > 0
+                      @worker_event.wait(@lock, wait_time)
+                    end
+
+                  when :ending, :shutdown
+                    flush_accumulating
+                    wrap_errors do
+                      shutdown
+                    end
+                    @status = :shutdown
+                    @shutdown_event.broadcast
+                    Thread.exit
+
+                  else
+                    error(AssertionError.new("Invalid status: #{@status}"))
+                    Thread.exit
+                end
+              end
+
+              # Swap existing stacks with new ones
+              writes, @write_stack = @write_stack, []
+              gathers, @gather_stack = @gather_stack, []
+            end
+
+            unwind(writes).each { |m| write_metric m }
+            unwind(gathers).each { |m| accumulate m }
+            flush_accumulating if should_flush?
+          end
+        end
+      end
+
+      def push(stack, value)
+        timestamp = now
+        pushed = false
+        @lock.synchronize do
+          if stack.length <= @limit and @status == :running
+            stack << timestamp << value
+            pushed = true
+            @worker_event.signal
+          end
+        end
+        pushed
+      end
+
+      def unwind(stack)
+        metrics = []
+        until stack.empty?
+          value = stack.pop
+          timestamp = stack.pop
+          wrap_errors do
+            case value
+              when Hash
+                value.each_pair { |k, v| metrics << Metric.new(k, v, timestamp) }
+              when Array
+                metrics.each do |m|
+                  if m.is_a? Metric
+                    metrics << m
+                  else
+                    error(AssertionError.new("Unhandled metric type: #{value.class}"))
+                  end
+                end
+              when Metric
+                metrics << value
+              else
+                error(AssertionError.new("Unhandled metric type: #{value.class}"))
+            end
+          end
+        end
+        metrics
+      end
+
+      def accumulate(metric)
+        if @accumulating.has_key? metric.key
+          @accumulating[metric.key] += metric.value
+        else
+          @accumulating[metric.key] = metric.value
+        end
+      end
+
+      def flush_accumulating
+        @accumulating.each_pair { |k, v| write_metric(Metric.new(k, v, now)) }
+        @accumulating.clear
+        @next_flush = now + @flush_interval
+      end
+
+      def should_flush?
+        now > @next_flush
+      end
+
+      def now
+        Time.now.to_f
+      end
+
+      def error(error)
+        if @error_handler.is_a? Proc
+          @error_handler.call(error)
+        end
+      end
+
+      def wrap_errors(&block)
+        begin
+          block.call
+        rescue Exception => e
+          error(e)
+        end
+      end
+    end
+  end
+end

data/lib/microphite/client/noop.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+module Microphite
+  module Client
+    class Noop < Base
+      def initialize(options={})
+        super(options)
+      end
+
+      protected
+
+      def write_metric(metric)
+      end
+    end
+  end
+end

data/lib/microphite/client/private/prefixed.rb

@@ -0,0 +1,49 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+module Microphite
+  module Client
+    module Private
+      class Prefixed < Client::Base
+        def initialize(client, prefix)
+          @client = client
+          @prefix = prefix
+        end
+
+        def write(metrics)
+          @client.write(mutate_hash(metrics))
+        end
+
+        def gather(metrics)
+          @client.gather(mutate_hash(metrics))
+        end
+
+        def time(key, &block)
+          @client.time("#{@prefix}#{key}") do
+            block.call
+          end
+        end
+
+        def prefix(additional, &block)
+          @client.prefix("#{@prefix}#{additional}", &block)
+        end
+
+        def close(timeout=nil)
+          @client.close(timeout)
+        end
+
+        private
+
+        def mutate_hash(hash)
+          return unless hash.is_a? Hash
+          mutated = {}
+          hash.each_pair do |k, v|
+            next unless k.is_a? String or k.is_a? Symbol
+            mutated[@prefix + k.to_s] = v
+          end
+          mutated
+        end
+      end
+    end
+  end
+end

data/lib/microphite/client/socket.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+require 'socket'
+require 'thread'
+
+module Microphite
+  module Client
+    class Socket < Base
+      def initialize(options)
+        defaults = {
+            port: 2003,           # Server port
+            transport: :udp,      # Transport: tcp or udp
+            min_delay: 2,         # Initial delay for write failures (seconds)
+            max_delay: 60,        # Maximum delay for write failures (seconds)
+        }
+        params         = defaults.merge(options)
+
+        # Read-only state
+        @host          = params[:host]
+        @port          = params[:port]
+        @transport     = params[:transport]
+        @min_delay     = params[:min_delay]
+        @max_delay     = params[:max_delay]
+
+        # Worker State
+        @socket        = nil
+
+        super(options)
+      end
+
+      protected
+
+      def shutdown
+        @socket.close unless @socket.nil?
+      end
+
+      private
+
+      def write_metric(metric)
+        sent = false
+        failure_delay = @min_delay
+        until sent
+          begin
+            new_socket if @socket.nil?
+            @socket.send(format_line(metric), 0)
+            sent = true
+
+          rescue Exception => e
+            error(e)
+
+            # TODO: More robust handling?
+            sleep failure_delay
+            new_socket
+            if failure_delay < @max_delay
+              failure_delay += 1
+            end
+          end
+        end
+      end
+
+      def new_socket
+        case @transport
+          when :tcp
+            @socket = TCPSocket.new(@host, @port)
+          when :udp
+            @socket = UDPSocket.new
+            @socket.connect(@host, @port)
+          else
+            error(AssertionError.new("Invalid transport: #{@transport}"))
+        end
+      end
+
+      def format_line(metric)
+        "#{@prefix}#{metric.key} #{format('%f', metric.value)} #{metric.time.to_i}\n"
+      end
+    end
+  end
+end

data/lib/microphite/client.rb

@@ -0,0 +1,4 @@
+require_relative 'client/base'
+require_relative 'client/noop'
+require_relative 'client/socket'
+require_relative 'client/private/prefixed'

data/lib/microphite/exceptions.rb

@@ -0,0 +1,4 @@
+module Microphite
+  class AssertionError < StandardError
+  end
+end

data/lib/microphite/metric.rb

@@ -0,0 +1,32 @@
+module Microphite
+  class Metric
+    attr_reader :key, :value, :time
+
+    def initialize(key, value, time=nil)
+      raise(ArgumentError, 'key cannot be nil') if key.nil?
+      raise(ArgumentError, 'value cannot be nil') if value.nil?
+
+      @key = key.to_s
+      @value = to_f! value
+      if time.nil?
+        @time = Time.now.to_f
+      else
+        @time = to_f! time
+      end
+
+      raise(ArgumentError, "invalid key: #{key}") if @key.empty?
+      raise(ArgumentError, "invaild value: #{value} ") if @value.nil?
+      raise(ArgumentError, "invalue time: #{time}") if @time.nil?
+    end
+
+    private
+
+    def to_f!(value)
+      begin
+        Float(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/microphite/version.rb

@@ -0,0 +1,3 @@
+module Microphite
+  VERSION = '0.5.0'
+end

data/lib/microphite.rb

@@ -0,0 +1,14 @@
+require_relative 'microphite/client'
+require_relative 'microphite/exceptions'
+require_relative 'microphite/metric'
+require_relative 'microphite/version'
+
+module Microphite
+  def self.client(options)
+    Client::Socket.new(options)
+  end
+
+  def self.noop(options=nil)
+    Client::Noop.new(options)
+  end
+end

data/microphite.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'microphite/version'
+
+Gem::Specification.new do |gem|
+  gem.name = 'microphite'
+  gem.version = Microphite::VERSION
+  gem.authors = %w(Bob Ziuchkovski)
+  gem.email = %w(bob@bz-technology.com)
+  gem.summary = 'A blazing fast, thread-safe graphite client'
+  gem.description = 'A blazing fast, thread-safe graphite client'
+  gem.homepage = 'https://github.com/bz-technology/microphite'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+
+  gem.files = `git ls-files`.split("\n")
+  gem.test_files = `git ls-files -- spec/*`.split("\n")
+  gem.require_paths = %w(lib)
+end

data/spec/client/noop_spec.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+require 'spec_helper'
+
+module Microphite
+  describe Client::Noop do
+    before_block = Proc.new { @client = Client::Noop.new }
+    after_block = Proc.new {}
+
+    it_should_behave_like 'a microphite client', before_block, after_block
+  end
+end

data/spec/client/socket_spec.rb

@@ -0,0 +1,181 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+require 'spec_helper'
+
+module Microphite
+  shared_examples 'a microphite socket client' do |transport|
+    before_block = Proc.new do
+      @server = Helpers::SingleServe.new(transport)
+      client_options = { host: 'localhost', port: @server.port, transport: transport }
+      @client = Client::Socket.new(client_options)
+    end
+    after_block = Proc.new {}
+
+    before do
+      instance_eval &before_block
+    end
+
+    it_should_behave_like 'a microphite client', before_block, after_block
+
+    describe :write do
+      it 'should handle Symbol and String keys' do
+        @client.write(key1: 1)
+        @client.write(key2: 2, key3: 3)
+        @client.write('key4' => 4)
+        @client.write('key5' => 5, 'key6' => 6)
+        @client.write('key7' => 7, :key8 => 8)
+        @client.write(:key9 => 9, 'key10' => 10)
+        @client.close
+
+        lines = @server.bytes
+        (1..10).each do |n|
+          lines.should match(/^key#{n} #{n}\.0* \d+$/)
+        end
+      end
+
+      it 'should handle Integer and Float values' do
+        @client.write(key1: 1)
+        @client.write(key2: 2.5)
+        @client.close
+
+        lines = @server.bytes
+        lines.should match(/^key1 1\.0* \d+$/)
+        lines.should match(/^key2 2\.50* \d+$/)
+      end
+    end
+
+    describe :gather do
+      it 'should handle Symbol and String keys' do
+        @client.gather(key1: 1)
+        @client.gather(key2: 2, key3: 3)
+        @client.gather('key4' => 4)
+        @client.gather('key5' => 5, 'key6' => 6)
+        @client.gather('key7' => 7, :key8 => 8)
+        @client.gather(:key9 => 9, 'key10' => 10)
+        @client.close
+
+        lines = @server.bytes
+        (1..10).each do |n|
+          lines.should match(/^key#{n} #{n}\.0* \d+$/)
+        end
+      end
+
+      it 'should handle Integer and Float values' do
+        @client.gather(key1: 1)
+        @client.gather(key2: 2.5)
+        @client.close
+
+        lines = @server.bytes
+        lines.should match(/^key1 1\.0* \d+$/)
+        lines.should match(/^key2 2\.50* \d+$/)
+      end
+
+      it 'should flush accumulated data' do
+        (1..10).each do
+          @client.gather(key1: 1)
+          @client.gather('key2' => 2)
+          @client.gather(:key3 => 3, 'key4' => 4)
+        end
+        @client.close
+
+        lines = @server.bytes
+        (1..4).each do |n|
+          lines.should match(/^key#{n} #{n * 10}\.0* \d+$/)
+        end
+      end
+
+      it 'should reset accumulated data after flush_interval' do
+        rst_server = Helpers::SingleServe.new(transport)
+        rst_options = { host: 'localhost', port: rst_server.port, transport: transport, flush_interval: 0.05 }
+        rst_client = Microphite::Client::Socket.new(rst_options)
+
+        rst_client.gather(key: 42)
+        sleep 0.075
+        rst_client.gather(key: 21)
+        rst_client.close
+
+        lines = rst_server.bytes
+        lines.should match(/^key 42\.0* \d+$/)
+        lines.should match(/^key 21\.0* \d+$/)
+      end
+    end
+
+    describe :time do
+      it 'should generate sensible values' do
+        before = Time.now.to_f
+        @client.time(:key) { 42 }
+        after = Time.now.to_f
+        outer_timing = after - before
+
+        @client.close
+        lines = @server.bytes
+        pattern = /^key (?<value>[0-9.]+) \d+$/
+
+        lines.should match(pattern)
+        value = pattern.match(lines)[:value]
+        value.should_not eq nil
+        expect { value > 0 and value < outer_timing }.to be_true
+      end
+    end
+
+    describe :prefix do
+      it 'should prefix :write' do
+        prefixed = @client.prefix('test.')
+        prefixed.write(:key1 => 1, 'key2' => 2)
+
+        @client.close
+        lines = @server.bytes
+        lines.should match(/^test.key1 1\.0* \d+$/)
+        lines.should match(/^test.key2 2\.0* \d+$/)
+      end
+
+      it 'should prefix :gather' do
+        prefixed = @client.prefix('test.')
+        prefixed.gather(:key1 => 1, 'key2' => 2)
+
+        @client.close
+        lines = @server.bytes
+        lines.should match(/^test.key1 1\.0* \d+$/)
+        lines.should match(/^test.key2 2\.0* \d+$/)
+      end
+
+      it 'should prefix :time' do
+        prefixed = @client.prefix('test.')
+        prefixed.time(:key) { 42 }
+
+        @client.close
+        lines = @server.bytes
+        lines.should match(/^test.key [0-9.]+ \d+$/)
+      end
+
+      it 'should prefix recursively' do
+        @client.prefix('p1.') do |p1|
+          p1.write(:key1 => 1)
+          p1.prefix('p2.') do |p2|
+            p2.gather(:key2 => 2)
+            p2.prefix('p3.') do |p3|
+              p3.time('key3') { 42 }
+            end
+          end
+        end
+
+        @client.close
+        lines = @server.bytes
+        lines.should match(/^p1.key1 [0-9.]+ \d+$/)
+        lines.should match(/^p1.p2.key2 [0-9.]+ \d+$/)
+        lines.should match(/^p1.p2.p3.key3 [0-9.]+ \d+$/)
+      end
+    end
+  end
+
+  describe Client::Socket do
+    context 'tcp' do
+      it_should_behave_like 'a microphite socket client', :tcp
+    end
+
+    context 'udp' do
+      it_should_behave_like 'a microphite socket client', :udp
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+require 'microphite'
+require 'socket'
+
+Dir['./spec/support/**/*.rb'].each { |file| require file }
+
+
+RSpec.configure do |config|
+  config.include Helpers
+end

data/spec/support/client_shared_examples.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+
+PUBLIC_METHODS = [:write, :gather, :time, :prefix, :close]
+
+shared_examples 'a microphite client' do |before, after|
+  before do
+    instance_eval &before
+  end
+
+  after do
+    instance_eval &after
+  end
+
+  describe 'interface' do
+    PUBLIC_METHODS.each do |method|
+      it 'should respond to ' + method.to_s do
+        @client.should respond_to method
+      end
+    end
+  end
+
+  describe :write do
+    it 'should tolerate valid input' do
+      expect { @client.write(key: 0) }.not_to raise_error
+      expect { @client.write(key1: 1, key2: 2.5) }.not_to raise_error
+    end
+  end
+
+  describe :gather do
+    it 'should tolerate valid input' do
+      expect { @client.gather(key: 0) }.not_to raise_error
+      expect { @client.gather(key1: 1, key2: 2.5) }.not_to raise_error
+    end
+  end
+
+  describe :time do
+    it 'should tolerate valid input' do
+      expect { @client.time(:key) { 42 } }.not_to raise_error
+      expect { @client.time('key') { 42 } }.not_to raise_error
+    end
+
+    it 'should return the evaluated block value' do
+      expect(@client.time(:key) { 42 }).to eq 42
+    end
+  end
+
+  describe :prefix do
+    it 'should return a client-like object' do
+      prefixed = @client.prefix 'test'
+      PUBLIC_METHODS.each do |method|
+        prefixed.should respond_to method
+      end
+    end
+  end
+
+  describe :close do
+    it 'should not blow up' do
+      expect { @client.close }.not_to raise_error
+    end
+  end
+end

data/spec/support/single_serve_helper.rb

@@ -0,0 +1,80 @@
+# Copyright (c) 2013 BZ Technology Services, LLC
+# Released under the MIT License (http://opensource.org/licenses/MIT)
+require 'socket'
+
+module Helpers
+  class SingleServe
+    # A super-simple RPC for stateless protocols (udp)
+    CLOSE_MAGIC = 'SingleServe.close()'
+
+    attr_reader :port
+
+    def initialize(transport)
+      @transport = transport.to_sym
+      @bytes = ''
+
+      case @transport
+        when :tcp
+          @socket = TCPServer.new('127.0.0.1', 0)
+          @port = @socket.addr[1]
+          @thread = Thread.new { tcp_loop }
+        when :udp
+          @socket = UDPSocket.new
+          @socket.bind('127.0.0.1', 0)
+          @port = @socket.addr[1]
+          @thread = Thread.new { udp_loop }
+        else
+          raise(ArgumentError, 'Only :tcp and :udp socket types supported')
+      end
+    end
+
+    # End the server, returning the data sent by the client
+    def bytes
+      if @thread.alive?
+        # UDP is stateless, so we have to indicate closure to the server
+        if @transport == :udp
+          closer = UDPSocket.new
+          closer.connect('127.0.0.1', @port)
+          closer.send CLOSE_MAGIC, 0
+        end
+        @thread.join
+      end
+      @bytes
+    end
+
+    private
+
+    def tcp_loop
+      client_socket = @socket.accept
+      read_fully client_socket
+      @bytes
+    end
+
+    def udp_loop
+      read_fully @socket
+      @bytes
+    end
+
+    def read_fully(socket)
+      loop do
+        readable = select([socket])[0]
+        if readable.empty?
+          return
+        else
+          begin
+            buffer = ''
+            socket.readpartial(4096, buffer)
+            @bytes << buffer
+            if @bytes.end_with? CLOSE_MAGIC
+              @bytes.chomp! CLOSE_MAGIC
+              return
+            end
+          rescue EOFError
+            @bytes << buffer
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,3 @@
+namespace :gem do
+  Bundler::GemHelper.install_tasks
+end

data/tasks/test.rake

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+namespace :test do
+  RSpec::Core::RakeTask.new do |t|
+    t.name = 'spec'
+    t.pattern = 'spec**/*_sped.rb'
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: microphite
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Bob
+- Ziuchkovski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A blazing fast, thread-safe graphite client
+email:
+- bob@bz-technology.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/microphite.rb
+- lib/microphite/client.rb
+- lib/microphite/client/base.rb
+- lib/microphite/client/noop.rb
+- lib/microphite/client/private/prefixed.rb
+- lib/microphite/client/socket.rb
+- lib/microphite/exceptions.rb
+- lib/microphite/metric.rb
+- lib/microphite/version.rb
+- microphite.gemspec
+- spec/client/noop_spec.rb
+- spec/client/socket_spec.rb
+- spec/spec_helper.rb
+- spec/support/client_shared_examples.rb
+- spec/support/single_serve_helper.rb
+- tasks/gem.rake
+- tasks/test.rake
+homepage: https://github.com/bz-technology/microphite
+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'
+      segments:
+      - 0
+      hash: 800344433168954481
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 800344433168954481
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A blazing fast, thread-safe graphite client
+test_files:
+- spec/client/noop_spec.rb
+- spec/client/socket_spec.rb
+- spec/spec_helper.rb
+- spec/support/client_shared_examples.rb
+- spec/support/single_serve_helper.rb