fluoride-collector 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79df9f5613527c47e3bfc8d757c779c992e0e34b
+  data.tar.gz: d00870129d5e02049f0d502dffcf5e2ba06f11e2
+SHA512:
+  metadata.gz: edcf5210f705bcf17fd40c5734a95537fe09877365761e6bfe68ccb159ceae23bbda5c949969fad19871418702695e648a3a38c22f2bd4e1ebcd36bb417923d0
+  data.tar.gz: 355afa02a28de428224911db463581798c9dec9d257e6ba91030056c3e8b7b07b55ec3ebfaebbb133acd3ba2d02a804f5c2e354b3ecb819ecd4c0533335b915a

data/lib/fluoride-collector.rb

@@ -0,0 +1,2 @@
+require 'fluoride-collector/middleware'
+require 'fluoride-collector/rails' if defined?(Rails)

data/lib/fluoride-collector/middleware.rb

@@ -0,0 +1,98 @@
+module Fluoride
+  module Collector
+    class Middleware
+      def initialize(app, directory, tagging = nil)
+        @app = app
+        @directory = directory
+        @tagging = tagging
+      end
+
+      def call(env)
+        @app.call(env).tap do |response|
+          record_exchange(env, response)
+        end
+      rescue Object => ex
+        record_exception(env, ex)
+        raise
+      end
+
+      private
+
+      def record_exchange(env, response)
+        store(
+          "type" => "normal_exchange",
+          "tags" => @tagging,
+          "request" => request_hash(env),
+          "response" => response_hash(response)
+        )
+      end
+
+      def record_exception(env, ex)
+        store(
+          "type" => "exception_raised",
+          "tags" => @tagging,
+          "request" => request_hash(env),
+          "response" => exception_hash(ex)
+        )
+      end
+
+      def request_hash(env)
+        body = nil
+        if env['rack.input'].respond_to? :read
+          body = env['rack.input'].read
+          env['rack.input'].rewind rescue nil
+        end
+        {
+          "content_type" => env['CONTENT_TYPE'],
+          "accept" => env["HTTP_ACCEPT_ENCODING"],
+          "referer" => env["HTTP_REFERER"],
+          "cookies" => env["HTTP_COOKIE"],
+          "authorization" => env["HTTP_AUTHORIZATION"],
+          "method" => env["REQUEST_METHOD"],
+          "host" => env['HTTP_HOST'] || "#{env['SERVER_NAME'] || env['SERVER_ADDR']}:#{env['SERVER_PORT']}",
+          "path" => env["SCRIPT_NAME"].to_s + env["PATH_INFO"].to_s,
+          "query_string" => env["QUERY_STRING"].to_s,
+          "body" => body,
+        }
+      end
+
+      def response_hash(response)
+        status, headers, body = *response
+
+        {
+          "status" => status,
+          "headers" => headers,
+          "body" => body.to_a.join("") #every body? all of it?
+        }
+      end
+
+      def exception_hash(ex)
+        {
+          "type" => ex.class.name,
+          "message" => ex.message,
+          "backtrace" => ex.backtrace[0..10]
+        }
+      end
+
+      def thread_locals
+        Thread.current[:fluoride_collector] ||= {}
+      end
+
+      def storage_path
+        thread_locals[:storage_path] ||= File::join(@directory, "collection-#{Process.pid}-#{Thread.current.object_id}.yml")
+      end
+
+      def storage_file
+        File::open(storage_path, "a") do |file|
+          yield file
+        end
+      end
+
+      def store(record)
+        storage_file do |file|
+          file.write(YAML::dump(record))
+        end
+      end
+    end
+  end
+end

data/lib/fluoride-collector/rails.rb

@@ -0,0 +1 @@
+require 'fluoride-collector/rails/railtie'

data/lib/fluoride-collector/rails/railtie.rb

@@ -0,0 +1,14 @@
+module Fluoride
+  module Collector
+    class Railtie < ::Rails::Railtie
+      config.fluoride = ActiveSupport::OrderedOptions.new
+      config.fluoride.tags = nil
+      config.fluoride.directory = "fluoride-collector"
+
+      initializer "fluoride-collector.add_middleware" do |app|
+        app.middleware.insert_after("ActionDispatch::ShowExceptions",
+                                    Fluoride::Collector::Middleware, config.fluoride.directory, config.fluoride.tags)
+      end
+    end
+  end
+end

data/spec/middleware.rb

@@ -0,0 +1,118 @@
+require 'rack'
+require 'fluoride-collector'
+
+describe Fluoride::Collector::Middleware do
+  include FileSandbox
+
+  let! :collection_directory do
+    dir = sandbox.new(:directory => "collections")
+    Dir.new(dir.path)
+  end
+
+  let :app do
+    run_app = test_app
+    Rack::Builder.app do
+      use Fluoride::Collector::Middleware, "collections", "TEST"
+      run run_app
+    end
+  end
+
+  let :env do
+    {}
+  end
+
+  describe "handling exception" do
+    let :test_ex_class do
+      Class.new(Exception)
+    end
+
+    let :test_app do
+      lambda{|env| raise test_ex_class, "test exception"}
+    end
+
+    it "should not change the response" do
+      expect{
+        app.call(env)
+      }.to raise_error
+    end
+
+    it "should create a collection file" do
+      expect do
+        begin
+          app.call(env)
+        rescue test_ex_class
+        end
+      end.to change{collection_directory.each.to_a.grep(/collection.*/).size}
+    end
+
+    it "should keep using the same collection file" do
+      begin
+        app.call(env)
+      rescue test_ex_class
+      end
+
+      expect do
+        begin
+          app.call(env)
+        rescue test_ex_class
+        end
+        path = File::join(collection_directory.path, collection_directory.each.to_a.grep(/collection.*/).first)
+      end.not_to change{collection_directory.each.to_a.grep(/collection.*/).size}
+    end
+
+    describe "creates a file" do
+      let :yaml do
+        begin
+          app.call(env)
+        rescue test_ex_class
+        end
+        path = File::join(collection_directory.path, collection_directory.each.to_a.grep(/collection.*/).first)
+        YAML.load_stream(File.read(path)).first
+      end
+
+      it "should have tags" do
+        yaml["tags"].should == "TEST"
+      end
+    end
+  end
+
+  describe "handling successful responses" do
+    let :test_app do
+      lambda{|env| response }
+    end
+
+    let :response do
+      [200, {'Content-Type' => 'text/plain'}, ['Just a test']]
+    end
+
+    it "should not change the response" do
+      app.call(env).should == response
+    end
+
+    it "should create a collection file" do
+      expect do
+        app.call(env)
+      end.to change{collection_directory.each.to_a.grep(/collection.*/).size}
+    end
+
+    it "should keep using the same collection file" do
+      app.call(env)
+      expect do
+        app.call(env)
+        path = File::join(collection_directory.path, collection_directory.each.to_a.grep(/collection.*/).first)
+      end.not_to change{collection_directory.each.to_a.grep(/collection.*/).size}
+    end
+
+    describe "creates a file" do
+      let :yaml do
+        app.call(env)
+        path = File::join(collection_directory.path, collection_directory.each.to_a.grep(/collection.*/).first)
+        YAML.load_stream(File.read(path)).first
+      end
+
+      it "should have tags" do
+        yaml["tags"].should == "TEST"
+      end
+    end
+  end
+end

data/spec/railtie.rb

@@ -0,0 +1,10 @@
+require 'railtie-help'
+
+describe Fluoride::Collector::Railtie do
+  it "should update the middleware stack" do
+    #Ugh :(
+
+    Rails.application.middleware.middlewares.should include(Fluoride::Collector::Middleware)
+  end
+
+end

data/spec_help/file-sandbox.rb

@@ -0,0 +1,164 @@
+#require 'ftools'
+require 'fileutils'
+
+module FileSandbox
+  def self.included(spec)
+    return unless spec.respond_to? :before
+
+    spec.before do
+      setup_sandbox
+    end
+
+    spec.after do
+      teardown_sandbox
+    end
+  end
+
+  class HaveContents
+    def initialize(contents)
+      @contents = contents
+    end
+
+    def matches?(target)
+      case @contents
+      when Regexp
+	@contents =~ target.contents
+      when String
+	@contents == target.contents
+      end
+    end
+  end
+
+  def have_contents(expected)
+    HaveContents.new(expected)
+  end
+
+  attr_reader :sandbox
+
+  def in_sandbox(&block)
+    raise "I expected to create a sandbox as you passed in a block to me" if !block_given?
+
+    setup_sandbox
+    original_error = nil
+
+    begin
+      yield @sandbox
+    rescue => e
+      original_error = e
+      raise
+    ensure
+      begin
+        teardown_sandbox
+      rescue
+        if original_error
+          STDERR.puts "ALERT: a test raised an error and failed to release some lock(s) in the sandbox directory"
+          raise(original_error)
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  def setup_sandbox(path = '__sandbox')
+    unless @sandbox
+      @sandbox = Sandbox.new(path)
+      @__old_path_for_sandbox = Dir.pwd
+      Dir.chdir(@sandbox.root)
+    end
+  end
+
+  def teardown_sandbox
+    if @sandbox
+      Dir.chdir(@__old_path_for_sandbox)
+      @sandbox.clean_up
+      @sandbox = nil
+    end
+  end
+
+  class Sandbox
+    attr_reader :root
+
+    def initialize(path = '__sandbox')
+      @root = File.expand_path(path)
+      clean_up
+      FileUtils.mkdir_p @root
+    end
+
+    def [](name)
+      SandboxFile.new(File.join(@root, name), name)
+    end
+
+    # usage new :file=>'my file.rb', :with_contents=>'some stuff'
+    def new(options)
+      if options.has_key? :directory
+        dir = self[options.delete(:directory)]
+        FileUtils.mkdir_p dir.path
+      else
+        file = self[options.delete(:file)]
+        if (binary_content = options.delete(:with_binary_content) || options.delete(:with_binary_contents))
+          file.binary_content = binary_content
+        else
+          file.content = (options.delete(:with_content) || options.delete(:with_contents) || '')
+        end
+      end
+
+      raise "unexpected keys '#{options.keys.join(', ')}'" unless options.empty?
+
+      dir || file
+    end
+
+    def remove(options)
+      name = File.join(@root, options[:file])
+      FileUtils.remove_file name
+    end
+
+    def clean_up
+      FileUtils.rm_rf @root
+      if File.exists? @root
+        raise "Could not remove directory #{@root.inspect}, something is probably still holding a lock on it"
+      end
+    end
+  end
+
+
+  class SandboxFile
+    attr_reader :path
+
+    def initialize(path, sandbox_path)
+      @path = path
+      @sandbox_path = sandbox_path
+    end
+
+    def inspect
+      "SandboxFile: #@sandbox_path"
+    end
+
+    def exist?
+      File.exist? path
+    end
+
+    def content
+      File.read path
+    end
+
+    def content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "w") {|f| f << content}
+    end
+
+    def binary_content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "wb") {|f| f << content}
+    end
+
+    def create
+      self.content = ''
+    end
+
+    alias exists? exist?
+    alias contents content
+    alias contents= content=
+    alias binary_contents= binary_content=
+  end
+end

data/spec_help/gem_test_suite.rb

@@ -0,0 +1,17 @@
+puts Dir::pwd
+require 'test/unit'
+begin
+  require 'spec'
+rescue LoadError
+  false
+end
+
+class RSpecTest < Test::Unit::TestCase
+  def test_that_rspec_is_available
+    assert_nothing_raised("\n\n *  RSpec isn't available - please run: gem install rspec  *\n\n"){ ::Spec }
+  end
+
+  def test_that_specs_pass
+    assert(system(*%w{spec -f e -p **/*.rb spec}),"\n\n *  Specs failed  *\n\n")
+  end
+end

data/spec_help/railtie-help.rb

@@ -0,0 +1,24 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+# Only the parts of rails we want to use
+# if you want everything, use "rails/all"
+require "action_controller/railtie"
+require "rails/test_unit/railtie"
+require 'fluoride-collector/rails'
+
+#root = File.expand_path(File.dirname(__FILE__))
+
+# Define the application and configuration
+module Fixture
+  class Application < ::Rails::Application
+    # configuration here if needed
+    config.active_support.deprecation = :stderr
+    config.eager_load = false
+  end
+end
+
+# Initialize the application
+Fixture::Application.initialize!
+
+RSpec.configure do |config|
+end

data/spec_help/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'rspec/core/formatters/base_formatter'
+require 'cadre/rspec'
+require 'file-sandbox'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.add_formatter(Cadre::RSpec::NotifyOnCompleteFormatter)
+  config.add_formatter(Cadre::RSpec::QuickfixFormatter)
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: fluoride-collector
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Judson Lester
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-06 00:00:00.000000000 Z
+dependencies: []
+description: |2
+    Part of the Fluoride suite - tools for making your black box a bit whiter
+email:
+- nyarly@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fluoride-collector/rails/railtie.rb
+- lib/fluoride-collector/rails.rb
+- lib/fluoride-collector/middleware.rb
+- lib/fluoride-collector.rb
+- spec/railtie.rb
+- spec/middleware.rb
+- spec_help/spec_helper.rb
+- spec_help/gem_test_suite.rb
+- spec_help/railtie-help.rb
+- spec_help/file-sandbox.rb
+homepage: http://nyarly.github.com/fluoride-collector
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --inline-source
+- --main
+- doc/README
+- --title
+- fluoride-collector-0.0.1 Documentation
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fluoride-collector
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Middleware to collect request and reponse pairs
+test_files:
+- spec_help/gem_test_suite.rb