profit 0.1.0

data/README.md

@@ -0,0 +1,28 @@
+# Profit (Profile It)
+
+![Step 3](http://thetrichordist.files.wordpress.com/2013/05/gnomes_plan.png)
+
+Profit is a client/server pair that lets you record timing data for your code.
+
+Here's the client
+``` ruby
+# my_ruby_app.rb
+client = Profit::Client.new
+client.start("some_suspect_code")
+some_thing_is_not_right
+client.stop("some_suspect_code")
+```
+
+Here's the server
+``` ruby
+server = Profit::Server.new
+server.run
+```
+
+And if you looked in Redis
+``` ruby
+irb(main):001:0>Redis.new(host: "127.0.0.1", port: 6379).lrange("some_foo_measurement", 0, -1)
+=> ["{\"recorded_time\":1.001161,\"start_file\":\"/Users/me/dev/my_ruby_app.rb\",\"start_line\":27,\"stop_file\":\"/Users/me/dev/my_ruby_app.rb\",\"stop_line\":27}"]
+```
+
+With this, you could track the data over time, see how some optimizations change the performance at runtime, make pretty graphs, you name it!

data/bin/profit_server

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'profit'
+
+Profit::Server.new.run

data/lib/profit/client.rb

@@ -0,0 +1,40 @@
+module Profit
+  class Client
+
+    attr_accessor :ctx, :socket, :pending
+
+    def initialize(ctx = nil)
+      @ctx = ctx || ZMQ::Context.new
+      @socket = @ctx.connect(:PUSH, "tcp://127.0.0.1:5556")
+      @pending = {}
+    end
+
+    def start(metric_type)
+      now = Time.now
+      start_file = caller[0][/(.+):(.+):/,1]
+      start_line = caller[0][/(.+):(.+):/,2].to_i + 1
+
+      # TODO: wrap in a Mutex & make the key a combo of metric_type,
+      #       pid, and/or thread object_id to make this thread safe and
+      #       thread-robust.
+      @pending[metric_type] = { start_file: start_file,
+                                start_line: start_line,
+                                start_time: now }
+    end
+
+    def stop(metric_type)
+      now = Time.now
+      metric = @pending.delete(metric_type)
+      recorded_time = Time.now - metric[:start_time]
+      stop_file = caller[0][/(.+):(.+):/,1]
+      stop_line = caller[0][/(.+):(.+):/,2].to_i - 1
+
+      @socket.send({ metric_type: metric_type,
+                     recorded_time: recorded_time,
+                     start_file: metric[:start_file],
+                     start_line: metric[:start_line],
+                     stop_file: stop_file,
+                     stop_line: stop_line }.to_json)
+    end
+  end
+end

data/lib/profit/message_handler.rb

@@ -0,0 +1,26 @@
+
+module Profit
+
+  class MessageHandler
+
+    include EM::Deferrable
+
+    attr_reader :text
+
+    def initialize(json, conn)
+      @json, @conn = json, conn
+    end
+
+    def run
+      return succeed("Starting") if @json.empty?
+      message_hash = JSON.parse(@json)
+      key = message_hash.delete("metric_type")
+      response = @conn.rpush key, message_hash.to_json
+      if response == "OK"
+        succeed response
+      else
+        fail response
+      end
+    end
+  end
+end

data/lib/profit/server.rb

@@ -0,0 +1,67 @@
+module Profit
+
+  class Server
+
+    attr_reader :ctx
+
+    def initialize
+      @ctx = ZMQ::Context.new
+    end
+
+    def shutdown!
+      @shutdown = true
+    end
+
+    def setup_trap_int
+      trap :INT do
+        puts "\nSIGINT received, quitting!"
+        EM.stop
+      end
+    end
+
+    def run
+      @run = true
+      EM.run do
+
+        @redis_pool = EM::Pool.new
+        spawn = lambda { @redis_pool.add Redis.new(host: "127.0.0.1", port: 6379) }
+        @redis_pool.on_error { |conn| spawn[] }
+        10.times { spawn[] }
+
+        @puller = @ctx.bind(:PULL, "tcp://127.0.0.1:5556")
+
+        # gives us a graceful exit
+        setup_trap_int
+
+        if @shutdown
+          EM.next_tick do # change to add_timer(1) for more delay
+            @run = false
+          end
+        end
+
+        # allows us to break out of the loop
+        EM.add_periodic_timer do
+          unless @run
+            EM.stop unless @run
+          end
+        end
+
+        # ensures we can continue to run other specs
+        EM.add_shutdown_hook { puts("destroy"); @ctx.destroy }
+
+        # this is the entry to message handling
+        EM.add_periodic_timer do
+          @redis_pool.perform do |conn|
+            message_handler = MessageHandler.new @puller.recv, conn
+
+            message_handler.callback do |response|
+              puts response.inspect
+            end
+            message_handler.run
+            message_handler
+          end
+        end
+      end
+    end
+  end
+end

data/lib/profit/version.rb

@@ -0,0 +1,3 @@
+module Profit
+  VERSION = "0.1.0"
+end

data/lib/profit.rb

@@ -0,0 +1,11 @@
+require 'zmq'
+require 'eventmachine'
+require 'redis'
+require 'json'
+
+module Profit
+end
+
+require 'profit/message_handler'
+require 'profit/server'
+require 'profit/client'

data/spec/lib/client_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Profit::Client do
+
+  let!(:redis)         { Redis.new(host: "127.0.0.1", port: 6379) }
+  let!(:client)        { Profit::Client.new(server.ctx) }
+  let!(:server)        { TestServer.server }
+  let!(:server_thread) { TestServer.server_thread }
+
+  after do
+    redis.del("some_foo_measurement")
+  end
+
+  it "sends the amount of time it takes to run some code" do
+    metrics = redis.lrange("some_foo_measurement", 0, -1)
+    expect(metrics).to be_empty
+
+    client.start("some_foo_measurement")
+    sleep 1
+    client.stop("some_foo_measurement")
+
+    server_thread.join(0.1)
+
+    metrics = redis.lrange("some_foo_measurement", 0, -1)
+    metric = JSON.parse(metrics.first)
+    expect(metric['recorded_time']).to be_within(0.1).of(1)
+  end
+
+  describe "#ctx" do
+
+    it "is a ZMQ context" do
+      expect(client.ctx).to be_a(ZMQ::Context)
+    end
+  end
+
+  describe "#new" do
+
+    it "connects to an open socket on a Profit::Server" do
+      expect(client.ctx).to be_a(ZMQ::Context)
+
+      expect(client.socket).to be_a(ZMQ::Socket)
+      expect(client.socket.to_s).to eq "PUSH socket connected to tcp://127.0.0.1:5556"
+    end
+
+    it "sends an initial message to notify the server of itself"
+  end
+
+  describe "#pending" do
+
+    it "is a Hash" do
+      expect(client.pending).to be_a(Hash)
+    end
+  end
+
+  describe "#start" do
+
+    it "starts the timer" do
+      expect(client.pending).to be_empty
+
+      client.start("some_foo_measurement")
+      now = Time.now
+
+      pending_metric = client.pending["some_foo_measurement"]
+      expect(pending_metric[:start_time].to_i).to be_within(1).of(now.to_i)
+    end
+
+    it "records where the execution starts" do
+      expect(client.pending).to be_empty
+
+      client.start("some_foo_measurement")
+      start_line = __LINE__
+      start_file = __FILE__
+
+      pending_metric = client.pending["some_foo_measurement"]
+      expect(pending_metric[:start_file]).to eq start_file
+      expect(pending_metric[:start_line]).to eq start_line
+    end
+  end
+
+  describe "#stop" do
+
+    after do
+      redis.del("m_1")
+      redis.del("m_2")
+    end
+
+    it "matches up with the start marker" do
+      client.start("m_1")
+      expect(client.pending.keys.count).to eq 1
+      sleep 0.3
+      client.start("m_2")
+      expect(client.pending.keys.count).to eq 2
+      sleep 1
+      client.stop("m_1")
+      client.start("m_1")
+      expect(client.pending.keys.count).to eq 2
+      sleep 0.2
+      client.stop("m_2")
+      expect(client.pending.keys.count).to eq 1
+      client.stop("m_1")
+
+      server_thread.join(0.1)
+
+      first_measurement_list = redis.lrange("m_1", 0, -1)
+      second_measurement_list = redis.lrange("m_2", 0, -1)
+
+      expect(first_measurement_list.count).to eq 2
+      expect(second_measurement_list.count).to eq 1
+
+      expect(JSON.parse(first_measurement_list[0])['recorded_time']).to be_within(0.1).of(1.3)
+      expect(JSON.parse(first_measurement_list[1])['recorded_time']).to be_within(0.1).of(0.2)
+      expect(JSON.parse(second_measurement_list[0])['recorded_time']).to be_within(0.1).of(1.2)
+    end
+
+    it "records where the execution stops" do
+      client.start("m_1")
+      sleep 0.1
+      stop_file = __FILE__
+      stop_line = __LINE__
+      client.stop("m_1")
+
+      server_thread.join(0.1)
+
+      measurements = redis.lrange("m_1", 0, -1)
+      metric = JSON.parse(measurements[0])
+      expect(metric['stop_file']).to eq stop_file
+      expect(metric['stop_line']).to eq stop_line
+    end
+  end
+end

data/spec/lib/server_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Profit::Server do
+
+  let!(:redis)         { Redis.new(host: "127.0.0.1", port: 6379) }
+  let!(:server)        { TestServer.server }
+  let!(:server_thread) { TestServer.server_thread }
+
+  after do
+    redis.del("some_slow_piece_of_code")
+  end
+
+  it "stores metrics messages" do
+    pusher = server.ctx.connect(:PUSH, "tcp://127.0.0.1:5556")
+
+    pusher.send({ recorded_time: (now = Time.now),
+                  total_time: 12.012,
+                  metric_type: "some_slow_piece_of_code",
+                  start_line: 1,
+                  end_line: 42,
+                  start_file: "/foo/bar/baz.rb",
+                  end_file: "/foo/bar/biz.rb" }.to_json)
+    server_thread.join(0.1)
+
+    list = redis.lrange("some_slow_piece_of_code", 0, -1)
+    expect(list.count).to eq 1
+    expect(redis.llen("some_slow_piece_of_code")).to eq 1
+
+    metric = JSON.parse(list[0])
+    expect(metric["total_time"]).to eq 12.012
+    expect(metric["start_line"]).to eq 1
+    expect(metric["end_line"]).to eq 42
+    expect(metric["start_file"]).to eq "/foo/bar/baz.rb"
+    expect(metric["end_file"]).to eq "/foo/bar/biz.rb"
+    expect(metric["recorded_time"]).to eq now.to_s
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require './lib/profit'
+
+class TestServer
+
+  def self.server
+    @@server ||= Profit::Server.new
+  end
+
+  def self.server_thread
+    @@server_thread ||= Thread.new { server.run }
+  end
+end
+
+RSpec.configure do |config|
+
+  config.before(:suite) do
+    TestServer.server
+  end
+
+  config.after(:suite) do
+    TestServer.server.shutdown!
+    TestServer.server_thread.join(1)
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: profit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dave Rogers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbczmq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  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'
+- !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'
+description: This is a client/server combination that allows you to profile code and
+  send the results to a remote Redis server.
+email:
+- david.t.rogers@gmail.com
+executables:
+- profit_server
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/profit/client.rb
+- lib/profit/message_handler.rb
+- lib/profit/server.rb
+- lib/profit/version.rb
+- lib/profit.rb
+- README.md
+- spec/lib/client_spec.rb
+- spec/lib/server_spec.rb
+- spec/spec_helper.rb
+- bin/profit_server
+homepage: https://github.com/davidtrogers/profit
+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: -3353567577735004538
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3353567577735004538
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple library to store profiling information for ruby code.
+test_files:
+- spec/lib/client_spec.rb
+- spec/lib/server_spec.rb
+- spec/spec_helper.rb