http_tracker 0.1.0

data/examples/mongodb.rb

@@ -0,0 +1,46 @@
+require "rubygems"
+require "http_tracker"
+require "sinatra"
+require "pp"
+require "mongo"
+
+class MongoTracker
+  include Mongo
+
+  def valid?(env); true; end
+
+  def on_request(env)
+    storage.save \
+      "ip" => env["REMOTE_ADDR"],
+      "path_info" => env["PATH_INFO"],
+      "method" => env["REQUEST_METHOD"]
+  end
+
+  def on_response(env, status, headers, body)
+    puts "Total requests made: #{storage.count}" 
+  end
+
+  private
+    def storage
+      @storage ||= begin
+        db_name, collection_name = "http_tracker_examples", "test"
+
+        connection = Connection.new.db(db_name)
+        unless connection.collection_names.include?(collection_name)
+          connection.create_collection(collection_name)
+        end
+
+        connection.collection(collection_name)
+      end
+    end
+end
+
+HTTPTracker::Manager.add(:mongo, MongoTracker)
+
+use HTTPTracker::Manager
+
+get "/foo" do
+  ":-)"
+end
+
+

data/examples/simple_tracker.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "http_tracker"
+require "sinatra"
+require "pp"
+
+HTTPTracker::Manager.add(:simple) do
+  def valid?(env); true; end
+
+  def on_request(env)
+    pp env
+  end
+end
+
+use HTTPTracker::Manager
+
+get "/foo" do
+  ":-)"
+end
+
+

data/lib/http_tracker/class_methods.rb

@@ -0,0 +1,32 @@
+module HTTPTracker
+  module ClassMethods
+    def add(label, klass = nil, &block)
+      if label.is_a?(Class) || (klass.nil? && !block_given?)
+        raise ArgumentError,
+          "A class or a block should be passed along with the tracker label."
+      end
+
+      klass ||= Class.new
+      if block_given?
+        klass.class_eval(&block)
+      end
+
+      tracker = klass.new
+
+      if !tracker.respond_to?(:on_request) && !tracker.respond_to?(:on_response)
+        raise ArgumentError,
+          "You should implement one of the following methods: on_response, on_request."
+      end
+
+      trackers[label] = klass
+    end
+
+    def trackers
+      @trackers ||= {}
+    end
+
+    def clear!
+      @trackers = {}
+    end
+  end
+end

data/lib/http_tracker/manager.rb

@@ -0,0 +1,50 @@
+module HTTPTracker
+  class Manager
+    extend ClassMethods
+
+    def initialize(app, options = {})
+      @app, @options = app, options
+      initialize_trackers
+    end
+
+    def call(env)
+      run_on_request_callbacks!(env)
+      
+      status, headers, body = @app.call(env)
+      
+      run_on_response_callbacks!(env, status, headers, body)
+
+      [status, headers, body]
+    end
+
+    private
+      def initialize_trackers
+        trackers.each_pair do |label, tracker_klass|
+          trackers[label] = tracker_klass.new
+        end
+      end
+
+      def trackers
+        self.class.trackers
+      end
+
+      def run_on_request_callbacks!(env)
+        run_callbacks(:request, env)
+      end
+
+      def run_on_response_callbacks!(env, status, headers, body)
+        run_callbacks(:response, env, status, headers, body)
+      end
+
+      def run_callbacks(name, *args)
+        env = args.first
+        method = "on_#{name}"
+
+        trackers.each_pair do |label, tracker|
+          if tracker.valid?(env) && tracker.respond_to?(method)
+            tracker.send(method, *args)
+          end
+        end
+      end
+  end
+end

data/lib/http_tracker.rb

@@ -0,0 +1,2 @@
+require 'http_tracker/class_methods'
+require 'http_tracker/manager'

data/spec/helpers/request_helper.rb

@@ -0,0 +1,26 @@
+module HTTPTracker::Spec
+  module Helpers
+
+    # Stolen from Warden http://github.com/hassox/warden
+    def env_with_params(path = "/", params = {}, env = {})
+      method = params.delete(:method) || "GET"
+      env = { 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => "#{method}" }.merge(env)
+      Rack::MockRequest.env_for("#{path}?#{Rack::Utils.build_query(params)}", env)
+    end
+
+    def basic_app
+      lambda  do |env|
+        [200, { "Content-Type" => "text/html" }, "yes!"] 
+      end
+    end
+
+    def setup_rack(middleware_class, options = {}, &block)
+      app ||= block_given? ? block : basic_app
+      Rack::Builder.new do
+        use middleware_class, options
+        run app
+      end
+    end
+
+  end
+end

data/spec/http_tracker/manager_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Manager do
+  after do
+    HTTPTracker::Manager.clear!
+  end
+
+  context "when adding new trackers" do
+    it "should be able to add trackers passing blocks" do
+      HTTPTracker::Manager.add(:foo) do
+        def valid?; end
+        def on_request; end
+        def on_response; end
+      end
+
+      HTTPTracker::Manager.trackers.should have(1).trackers
+      klass = HTTPTracker::Manager.trackers[:foo]
+
+      tracker = klass.new
+      tracker.respond_to?(:valid?).should be_true
+      tracker.respond_to?(:on_request).should be_true
+      tracker.respond_to?(:on_response).should be_true
+    end
+
+    it "should be able to add trackers using classes" do
+      klass = Class.new do
+        def valid?; end
+        def on_request; end
+        def on_response; end
+      end
+      HTTPTracker::Manager.add(:foo, klass)
+
+      klass = HTTPTracker::Manager.trackers[:foo]
+
+      tracker = klass.new
+      tracker.respond_to?(:valid?).should be_true
+      tracker.respond_to?(:on_request).should be_true
+      tracker.respond_to?(:on_response).should be_true
+    end
+
+    it "should raise an error if a name and a class aren't provided" do
+      lambda {
+        HTTPTracker::Manager.add(Class.new)
+      }.should raise_error
+
+      lambda {
+        HTTPTracker::Manager.add("foo")
+      }.should raise_error
+    end
+
+    it "it should make the #valid? method obligatory" do
+      lambda {
+        HTTPTracker::Manager.add(:foo) do
+          def valid?; end
+        end
+      }.should raise_error
+    end
+
+    it "should be obligatory to implement on of the following methods: #on_request, #on_response" do
+      lambda {
+        HTTPTracker::Manager.add(:foo) do
+          def valid?; end
+          def on_request; end
+        end
+      }.should_not raise_error
+
+      lambda {
+        HTTPTracker::Manager.add(:foo) do
+          def valid?; end
+          def on_response; end
+        end
+      }.should_not raise_error
+
+    end
+  end
+
+  context "when processing a request" do
+    before do
+      HTTPTracker::Manager.add(:foo) do
+        def valid?(env)
+          true
+        end
+
+        def on_request(env)
+          @x = 5
+        end
+
+        def on_response(env, status, headers, body)
+          @y = 10
+        end
+      end
+
+      HTTPTracker::Manager.add(:invalid) do
+        def valid?(env)
+          false
+        end
+
+        def on_request(env)
+          @NOT = 666
+        end
+
+        def on_response(env, status, headers, body)
+          @SHOULD_NOT_BE_SET = "SERIOUSLY"
+        end
+      end
+
+      @app = setup_rack(HTTPTracker::Manager)
+    end
+
+    context "when in middle of resquests" do
+      it "should initialize its trackers before processing the request" do
+        foo_tracker = HTTPTracker::Manager.trackers[:foo]
+
+        [:valid?, :on_request, :on_response].each do |method|
+          foo_tracker.respond_to?(method).should be_false
+        end
+
+        @app.call(env_with_params)
+        
+        foo_tracker = HTTPTracker::Manager.trackers[:foo]
+        [:valid?, :on_request, :on_response].each do |method|
+          foo_tracker.respond_to?(method).should be_true
+        end
+      end
+
+      it "should never initialize its trackers more than once"
+
+    end
+
+    it "should should run its before callbacks before processing the request" do
+      @app.call(env_with_params)
+      foo_tracker = HTTPTracker::Manager.trackers[:foo]
+      foo_tracker.instance_variable_get("@x").should == 5
+    end
+
+    it "should should run its after callbacks before processing the request" do
+      @app.call(env_with_params)
+      foo_tracker = HTTPTracker::Manager.trackers[:foo]
+      foo_tracker.instance_variable_get("@y").should == 10
+    end
+
+    it "should only execute the callbacks if the tracker is valid the environment" do
+      @app.call(env_with_params)
+      invalid_tracker = HTTPTracker::Manager.trackers[:invalid]
+      invalid_tracker.instance_variable_get("@SHOULD_NOT_BE_SET").should be_nil
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+
+require "rubygems"
+require "http_tracker"
+require "rspec"
+require "rack"
+require "pp"
+
+Dir[File.join(File.dirname(__FILE__), "helpers", "**/*.rb")].each do |f|
+  require f
+end
+
+include HTTPTracker
+
+Rspec.configure do |config|
+  config.include(HTTPTracker::Spec::Helpers)
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: http_tracker
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dalto Curvelano Junior
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-07 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/http_tracker/class_methods.rb
+- lib/http_tracker/manager.rb
+- lib/http_tracker.rb
+- spec/helpers/request_helper.rb
+- spec/http_tracker/manager_spec.rb
+- spec/spec_helper.rb
+- examples/mongodb.rb
+- examples/simple_tracker.rb
+has_rdoc: true
+homepage: http://github.com/dlt/request_tracker
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A simple and modular rack middleware to track http requests
+test_files: 
+- spec/helpers/request_helper.rb
+- spec/http_tracker/manager_spec.rb
+- spec/spec_helper.rb
+- examples/mongodb.rb
+- examples/simple_tracker.rb