fnord-client 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ross Kaffenberger
+
+MIT License
+
+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,44 @@
+# Fnord::Client
+
+Send events to an [FnordMetric](https://github.com/paulasmuth/fnordmetric) server via UDP (or TCP).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fnord-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fnord-client
+
+## Usage
+
+```ruby
+# Connect to FnordMetric inbound stream over UDP (default)
+$fnord = Fnord::Client('localhost', 1337)
+
+# Connect to FnordMetric inbound stream over TCP
+$fnord = Fnord::Client('localhost', 1337, :protocol => :tcp)
+
+# send JSON-encoded event
+$fnord.event("message_received", { :user_id => 123 })
+# "{\"_type\":\"message_received\",\"user_id\":\"123\"}"
+
+# configure FnordMetric namespace
+Fnord::Client.namespace = "staging"
+$fnord.event("message_received")
+# "{\"_type\":\"message_received\",\"_namespace\":\"staging\"}"
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc "Run the specs"
+task :default => ["spec"]

data/fnord-client.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/fnord/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ross Kaffenberger"]
+  gem.email         = ["rosskaff@gmail.com"]
+  gem.description   = %q{A client for sending events to an FnordMetric server over UDP (or TCP)}
+  gem.summary       = %q{A client for sending events to an FnordMetric server over UDP (or TCP)}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = "fnord-client"
+  gem.require_paths = ["lib"]
+  gem.version       = Fnord::VERSION
+
+  gem.add_dependency "yajl-ruby"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/lib/fnord-client.rb

@@ -0,0 +1,7 @@
+require "fnord/version"
+
+module Fnord
+  autoload :Client, 'fnord/client'
+  autoload :UDPConnection, 'fnord/udp_connection'
+  autoload :TCPConnection, 'fnord/tcp_connection'
+end

data/lib/fnord/client.rb

@@ -0,0 +1,67 @@
+require 'yajl'
+
+module Fnord
+  class Client
+    attr_reader :host, :port, :options
+
+    class << self
+      # Set to any standard logger instance (including stdlib's Logger) to enable
+      # stat logging using logger.debug
+      attr_accessor :logger, :namespace
+    end
+
+    attr_accessor :connection
+
+    def initialize(host, port = 1337, options = {})
+      @host, @port, @options = host, port, options
+    end
+
+    def event(*args)
+      message = extract_options!(args)
+      event_name = args.shift
+      message[:_type] = event_name if event_name
+      message[:_namespace] = self.class.namespace unless message[:_namespace]
+      message = stringify_values(message)
+      send_to_connection(to_json(message))
+    end
+
+    def connection
+      @connection ||= connection_class.new(@host, @port, @options)
+    end
+
+    private
+
+    def protocol
+      @protocol ||= @options.delete(:protocol) || :udp
+    end
+
+    def connection_class
+      case protocol
+      when :tcp
+        TCPConnection
+      else
+        UDPConnection
+      end
+    end
+
+    def send_to_connection(message)
+      self.class.logger.debug {"Fnord: #{message}"} if self.class.logger
+      connection.send_data(message)
+    rescue => boom
+      self.class.logger.error {"Fnord: #{boom.class} #{boom}"} if self.class.logger
+    end
+
+    def stringify_values(message)
+      {}.tap { |hash| message.each { |k, v| hash[k] = v.to_s } }
+    end
+
+    def extract_options!(args)
+      args.last.is_a?(::Hash) ? args.pop : {}
+    end
+
+    def to_json(hash)
+      Yajl::Encoder.encode(hash)
+    end
+
+  end
+end

data/lib/fnord/tcp_connection.rb

@@ -0,0 +1,63 @@
+module Fnord
+  class TCPConnection
+
+    attr_accessor :socket
+
+    def initialize(host, port = 1337, options = {})
+      @host, @port, @options = host, port, options
+    end
+
+    def send_data(data)
+      ensure_connected(:retry => true) do
+        # Rails.logger.info "[FNORD] Sending data\n#{data}"
+        @socket.puts(data)
+        @socket.flush
+      end
+    end
+
+    def connect
+      @socket = TCPSocket.new(@host, @port)
+    end
+
+    def reconnect
+      # untested
+      disconnect
+      connect
+    end
+
+    def disconnect
+      # untested
+      return unless connected?
+
+      begin
+        @socket.close
+      rescue
+      ensure
+        @socket = nil
+      end
+    end
+
+    def connected?
+      !!@socket
+    end
+
+    private
+
+    def ensure_connected(opts = {}, &block)
+      begin
+        connect unless connected?
+        yield
+      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::ECONNREFUSED => e
+        if opts[:retry]
+          ensure_connected(:retry => false, &block)
+        else
+          if @options[:raise_errors]
+            raise e
+          else
+            # Rails.logger.warn "[FNORD] Could not connect to fnord at #{@host}:#{@port}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fnord/udp_connection.rb

@@ -0,0 +1,21 @@
+module Fnord
+  class UDPConnection
+
+    attr_accessor :socket
+
+    def initialize(host, port = 1337, options = {})
+      @host, @port, @options = host, port, options
+    end
+
+    def send_data(data)
+      # Rails.logger.info "[FNORD] Sending data\n#{data}"
+      socket.send(data, 0, @host, @port)
+    end
+
+    def socket
+      @socket ||= UDPSocket.new
+    end
+
+  end
+
+end

data/lib/fnord/version.rb

@@ -0,0 +1,3 @@
+module Fnord
+  VERSION = "0.0.1"
+end

data/spec/fnord/client_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Fnord::Client do
+  let(:client) { Fnord::Client.new('localhost', 1339) }
+  let(:connection) { stub(Fnord::UDPConnection) }
+
+  describe "initialize" do
+    before { Fnord::Client.namespace = "clientapp_test" }
+    it { Fnord::Client.namespace.should == "clientapp_test" }
+    it { client.host.should == 'localhost' }
+    it { client.port.should == 1339 }
+  end
+
+  describe "event" do
+    before { client.connection = connection }
+
+    it "should send hash as json via connection" do
+      data = { "one" => "1" }
+      connection.should_receive(:send_data).with(%Q|{"one":"1","_namespace":"clientapp_test\"}|)
+      client.event(data)
+    end
+
+    it "should send numeric values as strings" do
+      data = { "one" => 1 }
+      connection.should_receive(:send_data).with(/#{%Q|"one":"1"|}/)
+      client.event(data)
+    end
+
+    it "should merge event type when given as first arg" do
+      data = { "one" => "1", "two" => 2 }
+      connection.should_receive(:send_data).with(%Q|{"one":"1","two":"2","_type":"logged_in","_namespace":"clientapp_test\"}|)
+      client.event("logged_in", data)
+    end
+  end
+
+  describe "connection" do
+    it "connects uses UDP strategy by default" do 
+      client.connection.should be_kind_of(Fnord::UDPConnection)
+    end
+
+    it "connects set TCP strategy via option" do 
+      client = Fnord::Client.new('localhost', 1337, :protocol => :tcp)
+      client.connection.should be_kind_of(Fnord::TCPConnection)
+    end
+  end
+end

data/spec/fnord/tcp_connection_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Fnord::TCPConnection do
+
+  class FakeTCPSocket
+
+    def puts(data)
+      @data ||= []
+      @data << data
+    end
+
+    def flush
+      @data = nil
+    end
+
+    def close; end
+  end
+
+  let(:connection) { Fnord::TCPConnection.new('localhost', 1337) }
+  let(:socket) { FakeTCPSocket.new }
+
+  before {
+    TCPSocket.stub!(:new).and_return(socket)
+    connection.socket = socket
+  }
+
+  describe "disconnect" do
+    it "closes the socket" do
+      socket.should_receive(:close)
+      connection.disconnect
+    end
+
+    it "removes socket reference" do
+      connection.disconnect
+      connection.socket.should be_nil
+    end
+  end
+
+  describe "connected?" do
+    it "true if socket exists" do
+      connection.socket = socket
+      connection.connected?.should be_true
+    end
+
+    it "false if socket doesn't exist" do
+      connection.socket = nil
+      connection.connected?.should be_false
+    end
+  end
+
+  describe "send_data" do
+
+    it "should puts data and flush over socket" do
+      socket.should_receive(:puts).with("data")
+      socket.should_receive(:flush)
+      connection.send_data("data")
+    end
+
+  end
+end

data/spec/fnord/udp_connection_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Fnord::UDPConnection do
+  class FakeUDPSocket
+    def send(data); end
+  end
+
+  let(:connection) {
+    Fnord::UDPConnection.new('localhost', 1339)
+  }
+  let(:socket) { FakeUDPSocket.new }
+
+  describe "send_data" do
+
+    it "should send data to initialized host, port" do
+      UDPSocket.should_receive(:new).and_return(socket)
+      socket.should_receive(:send).with("data", 0, 'localhost', 1339)
+      connection.send_data("data")
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'rspec/autorun'
+require 'fnord-client'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: fnord-client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ross Kaffenberger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70294812549400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70294812549400
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70294812548960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70294812548960
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70294812548540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70294812548540
+description: A client for sending events to an FnordMetric server over UDP (or TCP)
+email:
+- rosskaff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- fnord-client.gemspec
+- lib/fnord-client.rb
+- lib/fnord/client.rb
+- lib/fnord/tcp_connection.rb
+- lib/fnord/udp_connection.rb
+- lib/fnord/version.rb
+- spec/fnord/client_spec.rb
+- spec/fnord/tcp_connection_spec.rb
+- spec/fnord/udp_connection_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: 3790659374809875027
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3790659374809875027
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A client for sending events to an FnordMetric server over UDP (or TCP)
+test_files:
+- spec/fnord/client_spec.rb
+- spec/fnord/tcp_connection_spec.rb
+- spec/fnord/udp_connection_spec.rb
+- spec/spec_helper.rb