abstract_analyzer 0.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+test/*.log
+lib/*.log
+lib/middlewares/*.log
+lib/middlewares/*.db
+*.db
+*.log

data/README.rdoc

@@ -0,0 +1,63 @@
+=Abstract Analyzer
+
+This is a Rack based analyzer. The idea is to use different methods and libraries to track requests on Rack app and report those back in some simple views.
+
+I'm starting with a Fiveruns Dash analyzer that reports to a MongoDB instance. Reporting actually be it's own small Rack app and for the time being, will mostly text based.
+
+==Requirements
+
+I hope to trim this down, but for now...
+
+gems:
+* mongodb-mongo
+* fiveruns-dash-ruby
+* usher
+* ruport
+
+In addition for the tests to pass, you need mongod running on localhost:27017
+
+==Implementation
+
+You can use the DashAnalyzer with any rack app you'd like. Check the tests for an example.
+
+===Rails
+
+If Rails is your bag, I've included a middleware implementation of the DashAnalyzer. Implementing is pretty easy.
+
+First, this thing isn't a gem yet, so just load the whole thing into lib or somewhere else Rails will see it.
+
+Secound, in RAILS_ROOT/config/initializers/middlewares.rb
+
+  require 'abstract_analyzer/abstract_analyzer'
+
+  # Setup the Analyzer DB
+  abstract_analyzer_db = Mongo::Connection.new('localhost', 27017).db('aa-rails-dash-analyzer-db')
+  AbstractAnalyzer.const_set("DB", abstract_analyzer_db)
+
+  # Setup the Analyzer LOGGER
+  abstract_logger = Logger.new("#{RAILS_ROOT}/log/abstract_analyzer_logger.log")
+  AbstractAnalyzer.const_set("LOGGER", abstract_logger)
+
+  # Use the Analyzer and View middlewares
+  ActionController::Dispatcher.middleware.use AbstractAnalyzer::Middleware::Rails::Dash::Analyzer
+  ActionController::Dispatcher.middleware.use AbstractAnalyzer::Middleware::Rails::Dash::View
+
+Third, make sure you actually have a mongo db running on localhost:27017 or change the connection accordingly ;)
+
+==Todo
+
+* Basic html views
+* Implementing reports for Non-time based metrics
+* Non-Rails middlewares?
+* Non-Dash implementations?
+
+==Props
+
+* Carl Lerche and Yehuda Katz for their Extending Rails training at the Lone Star Ruby Conference that planted this seed 
+* The company formally known as Fiveruns for open sourcing their reporter gems
+* Adam Keys for explaining how the Dash gems work
+* The guys a SqueeJee for saying MongoDB enough times to make me try it in something
+
+==License
+
+See LICENSE

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "abstract_analyzer"
+    gem.summary = %Q{A rack based app analyzer}
+    gem.email = "markmcspadden@gmail.com"
+    gem.homepage = "http://github.com/garlandgroup/abstract-analyzer"
+    gem.authors = ["Mark McSpadden"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'abstract_analyzer'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 0

data/lib/abstract_analyzer.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) << '/view'
+require File.dirname(__FILE__) << '/dash_analyzer'
+require File.dirname(__FILE__) << '/middleware'
+
+module AbstractAnalyzer
+  
+  # CONSTANTS DB, LOGGER, STORE are currently being set and expected
+  
+  # STORE = "mongoDB"
+  # DB = Mongo::Connection.new('localhost', 27017).db('abstract-analyzer-db')      
+  # LOGGER = Logger.new(File.dirname(__FILE__) << "/abstract_analyzer_logger.log")
+  
+end
+
+
+

data/lib/dash_analyzer.rb

@@ -0,0 +1,24 @@
+require 'yaml'
+
+require 'logger'
+
+require 'rubygems' # I know I know...
+
+
+gem 'fiveruns-dash-ruby' # Put its path first
+require 'fiveruns/dash'
+
+require 'mongo'  
+
+require File.dirname(__FILE__) << '/dash_analyzer/dash_extensions'
+require File.dirname(__FILE__) << '/dash_analyzer/base'
+require File.dirname(__FILE__) << '/dash_analyzer/view'
+
+module DashAnalyzer
+
+end
+
+
+
+
+

data/lib/dash_analyzer/base.rb

@@ -0,0 +1,55 @@
+module DashAnalyzer
+  # Hooks up dash to your db
+  # Implement in as a middleware like so:
+  #
+  # class MyApp < DashAnalyzer::Base 
+  #   Fiveruns::Dash.register_recipe :testpack, :url => 'http://example.org' do |recipe|
+  #     Fiveruns::Dash.logger.info 'REGISTERING ACTIONPACK RECIPE'
+  #     recipe.time :response_time, :method => 'DashAnalyzer::Base#call', :mark => true
+  #     recipe.time :another_response_time, :method => 'DashAnalyzer::Base#call', :mark => true
+  #   end
+  #   
+  #   def initialize(*)
+  #     @recipes = [{:name => :testpack, :url => 'http://example.org'}]
+  #     super
+  #   end 
+  # end
+  #  
+  class Base
+    attr_accessor :db, :logger
+       
+    def initialize(app, dash_interval=60)      
+      @db = AbstractAnalyzer.const_get("DB")
+      @logger = AbstractAnalyzer.const_get("LOGGER")
+      
+      startup_dash(dash_interval)
+      
+      @app = app
+    end
+ 
+    def call(env)       
+      @app.call(env)       
+    end
+    
+    def startup_dash(interval = 60)
+      return if Fiveruns::Dash.session.reporter.started?
+      
+      Fiveruns::Dash.session.reset
+      
+      Fiveruns::Dash.logger = @logger
+      
+      ENV['DASH_UPDATE'] = "mongo://db"
+           
+      Fiveruns::Dash.configure do |config|
+        config.db = db
+                
+        @recipes.each do |r|
+          config.add_recipe r[:name], r[:url]
+        end
+      end
+
+      Fiveruns::Dash.session.interval = interval
+      Fiveruns::Dash.session.start
+    end
+  end
+end

data/lib/dash_analyzer/dash_extensions.rb

@@ -0,0 +1,88 @@
+# Setup db to receive rollups
+class Fiveruns::Dash::Configuration
+  attr_accessor :db
+end
+
+# Allow the Fiveruns::Dash::Session interval to be set
+module FiverunsDashSessionExtensions
+  def interval=(value)
+    reporter.interval = value
+  end  
+end
+Fiveruns::Dash::Session.__send__ :include, FiverunsDashSessionExtensions
+
+
+# Allow direct access to the Fiveruns::Dash::Payload data hash
+module FiverunsDashPayloadExtensions
+  attr_reader :data
+end
+Fiveruns::Dash::Payload.__send__ :include, FiverunsDashPayloadExtensions
+
+# Setup a store_mongo method on Fiveruns::Dash::Store
+# NOTE: I think there is a better way to do this
+module Fiveruns::Dash::Store::Mongo
+  def store_mongo(*uris)    
+    Fiveruns::Dash.logger.info "Attempting to send #{payload.class}"
+  
+    if payload.is_a? Fiveruns::Dash::DataPayload
+      data = payload.data
+
+      data.each do |d|
+        recipe_name = d[:recipe_name]
+        name = d[:name]
+        storage_name = "#{recipe_name}-#{name}"
+        d[:created_at] = Time.now
+        
+        # TODO: Use upsert to handle cluser wide implementations
+        Fiveruns::Dash.session.configuration.db.collection(storage_name).insert(d)
+        Fiveruns::Dash.logger.info "Sent #{payload.class} to #{Fiveruns::Dash.session.configuration.db}"
+      end
+    else
+      raise "Payload of type #{payload.class} Not Currently Supported"
+    end
+  rescue
+    Fiveruns::Dash.logger.warn "Could not send #{payload.class}: #{$!}"
+  end
+end
+
+# Allow Fiveruns::Dash::Update to recognize mongo style urls
+# Yes I think I totally just made up mongo style urls
+# They look like 'mongo://ANYTHING_GOES_HERE_FOR_NOW'
+
+# Also, I think I like the duck punching better than this send/include/send/alias_method mess
+# Open to rewrites
+module FiverunsDashUpdateExtensions
+  include Fiveruns::Dash::Store::Mongo
+    
+  private
+  def storage_method_for_with_mongo(scheme)
+    if scheme =~ /^mongo/ 
+      :mongo
+    else
+      storage_method_for_without_mongo(scheme)
+    end
+  end
+end
+Fiveruns::Dash::Update.__send__ :include, FiverunsDashUpdateExtensions
+Fiveruns::Dash::Update.__send__ :alias_method, :storage_method_for_without_mongo, :storage_method_for
+Fiveruns::Dash::Update.__send__ :alias_method, :storage_method_for, :storage_method_for_with_mongo
+
+# Duck punched version
+# module Fiveruns::Dash
+#   class Update
+#     include Store::Mongo
+#     
+#     private
+# 
+#     def storage_method_for_with_mongo(scheme)
+#       if scheme =~ /^mongo/ 
+#         :mongo
+#       else
+#         storage_method_for_without_mongo(scheme)
+#       end
+#     end
+#     # alias_method_chain :storage_method_for, :mongo
+#     alias_method :storage_method_for_without_mongo, :storage_method_for
+#     alias_method :storage_method_for, :storage_method_for_with_mongo    
+#   end
+# end

data/lib/dash_analyzer/view.rb

@@ -0,0 +1,89 @@
+require 'ruport'
+
+module DashAnalyzer
+  class TimeView < AbstractAnalyzer::View
+    
+    def initialize(*)
+      super
+      setup_show
+    end
+    
+    # Create some kind of index view
+    get "/analytics" do      
+      # Only look at time metrics for now
+      collection_names = db.collection_names.select{ |n| n.match(/time/)}
+      
+      table = Table(:column_names => ["Metric", "Total Number of Calls", "Total Time (s)", "Avg Time per Call (s)"])
+      
+      collection_names.each do |name|        
+        coll = db.collection(name)              
+        
+        total_values = 0
+        total_invocations = 0
+        
+        coll.find().each do |row|
+          values = row["values"]
+
+          # Why is this an array
+          if values && !values.empty?
+            v = values.first
+            value = v["value"]
+            invocations = v["invocations"]
+
+            total_values += value.to_f
+            total_invocations += invocations.to_i
+          end
+        end
+        
+        table << [name.to_s.titlecase, total_invocations.to_i, total_values.to_f, total_values.to_f/total_invocations.to_f]
+      end
+      
+      trail = "There are more details at:\n#{collection_names.collect{ |n| " * /analytics/show/#{n}"}.join("\n")}"
+      
+      [table.to_s, trail].join("\n")
+    end
+    
+    # Use the collection names to create views
+    def setup_show
+      db.collection_names.each do |name|
+        self.class.class_eval do
+          get "/analytics/show/#{name}" do
+            coll = db.collection(name)
+
+            lead = "Listing #{coll.count} #{name.to_s.titlecase} Rollups in the Last Hour"
+    
+            table = Table(:column_names => ["Time", "Metric Name", "Number of Calls", "Total Time"])
+
+            total_invocations = 0
+            total_values = 0.0
+
+            # TODO: Reverse this collection
+            coll.find({:created_at => {:$gte => Time.now.advance(:hours => -1)}}, {:sort => {:created_at => Mongo::DESCENDING}}).each do |row|
+              values = row["values"]
+        
+              # Why is this an array
+              if values && !values.empty?
+                value = values.first["value"]
+                invocations = values.first["invocations"]
+          
+                total_values = value.to_f
+                total_invocations += invocations.to_i
+              end
+        
+              table << [row["created_at"], row["description"], invocations.to_i, value.to_f]
+            end
+      
+            results = []
+            results << "Total Calls: #{total_invocations}"
+            results << "Total Time: #{total_values} seconds"
+            results << "Avg Time per Call: #{total_values/total_invocations.to_f} seconds"
+            results = results.join("\n")
+
+            [lead, results, table.to_s].join("\n")
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/middleware.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) << '/middleware/rails'
+
+module AbstractAnalzyer
+  module Middleware
+  
+  end
+end

data/lib/middleware/rails.rb

@@ -0,0 +1,41 @@
+# TODO: Figure out what to do with these.
+# They already be loaded if it's actually in a Rails project
+# But if it's not, we'd hate to load all this mess.
+
+RAILS_ROOT = File.dirname(__FILE__) unless defined?(RAILS_ROOT)
+RAILS_DEFAULT_LOGGER = Logger.new(File.dirname(__FILE__) << "/middleware_rails_dash.log") unless defined?(RAILS_DEFAULT_LOGGER)
+gem 'rails'
+gem 'activesupport'
+gem 'activerecord'
+gem 'actionpack'
+require 'action_controller'
+require 'action_controller/base'
+
+
+
+require File.dirname(__FILE__) << '/rails/dash'
+
+module AbstractAnalyzer
+  module Middleware
+    # Implementation
+    # In RAILS_ROOT/config/initializers/middlewares.rb
+    #
+    #   require 'abstract_analyzer/abstract_analyzer'
+    #
+    #   # Setup the Analyzer DB
+    #   abstract_analyzer_db = Mongo::Connection.new('localhost', 27017).db('aa-rails-dash-analyzer-db')
+    #   AbstractAnalyzer.const_set("DB", abstract_analyzer_db)
+    # 
+    #   # Setup the Analyzer LOGGER
+    #   abstract_logger = Logger.new("#{RAILS_ROOT}/log/abstract_analyzer_logger.log")
+    #   AbstractAnalyzer.const_set("LOGGER", abstract_logger)
+    # 
+    #   # Use the Analyzer and View middlewares
+    #   ActionController::Dispatcher.middleware.use AbstractAnalyzer::Middleware::Rails::Dash::Analyzer
+    #   ActionController::Dispatcher.middleware.use AbstractAnalyzer::Middleware::Rails::Dash::View
+    #
+    # NOTE: The require piece will be replace by an environment.rb config.gem call at some point
+    module Rails
+    end
+  end
+end

data/lib/middleware/rails/dash.rb

@@ -0,0 +1,35 @@
+require 'fiveruns-dash-rails'
+
+module AbstractAnalyzer
+  module Middleware
+    module Rails
+      module Dash  
+        # This is where we grab the analytics
+        class Analyzer < DashAnalyzer::Base
+          # Fiveruns::Dash.register_recipe :actionpack, :url => 'http://example.org' do |recipe|
+          #   Fiveruns::Dash.logger.info 'REGISTERING ACTIONPACK RECIPE'
+          #       
+          #   recipe.time :response_time, :method => 'AbstractController::Base#process_action', :mark => true
+          # end
+    
+          def initialize(*)
+            # Fiveruns::Dash::Rails.load_recipes
+            
+            #@recipes = [{:name => :actionpack, :url => 'http://example.org'}]
+            @recipes = [{:name => :ruby, :url => 'http://dash.fiveruns.com'},
+                        {:name => :rails, :url => 'http://dash.fiveruns.com'}]
+            super
+          end
+        end
+  
+        # This is where we view them
+        class View < DashAnalyzer::TimeView
+           def initialize(*)
+             super
+             #self.collection = 'actionpack-response_time'
+           end
+        end
+      end
+    end
+  end
+end

data/lib/view.rb

@@ -0,0 +1,75 @@
+require 'usher'
+
+module AbstractAnalyzer
+  class View
+    def db
+      AbstractAnalyzer.const_get("DB")
+    end
+
+    attr_accessor :collection
+    def initialize(app, collection = nil)
+      @collection = collection.to_s    
+      @app = app
+    end
+
+    def call(env)
+      method_name = "[#{env["REQUEST_METHOD"].to_s.downcase}] #{env["PATH_INFO"]}"
+
+      # This has got to be not good for performance
+      # Consider using the PATH_INFO var instead      
+      if self.respond_to?(method_name)
+        content = self.__send__(method_name)
+        [200, {"Content-Type" => "text/plain"}, content]
+      else
+        @app.call(env)
+      end
+    end
+    
+    class << self
+      # From Railsnatra
+      # Set @_routes on child classes
+      def inherited(klass)
+        klass.class_eval { @_routes = [] }
+      end
+      
+      def to_app
+        routes, controller = @_routes, self
+
+        # From Railsnatra ;)
+        # We're using Usher as a router for this project. To
+        # simplify things, we just used the rack interface to
+        # router and it's DSL.
+        app = Usher::Interface.for(:rack) do
+          routes.each do |route|
+            conditions = {:request_method => route[:method]}
+            add(route[:uri], :conditions => conditions.merge(route[:options])).
+              to(controller.action(route[:action]))
+          end
+        end
+
+        app
+      end
+      
+      def get(uri, options = {}, &block)
+        route(:get,  uri, options, &block)
+      end
+      
+      private
+      # From Railsnatra
+      def route(http_method, uri, options, &block)
+        # Since we need unique actions for each possible GET,
+        # POST, etc... URLs, we add the method in the action
+        # name. ActionController::Metal has the ability to
+        # route an action with any name format.
+        action_name = "[#{http_method}] #{uri}"
+        # We save the route options in the global @_routes
+        # variable so that we can build the routes when the
+        # app is generated.
+        @_routes << {:method => http_method.to_s.upcase, :uri => uri,
+                     :action => action_name, :options => options}
+        # Now, we finally create the action method.
+        define_method(action_name, &block)
+      end 
+    end
+  end
+end

data/test/lib/dash_analyzer/test_base.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class BaseTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  class MyApp < DashAnalyzer::Base
+        
+    Fiveruns::Dash.register_recipe :testpack, :url => 'http://example.org' do |recipe|
+      Fiveruns::Dash.logger.info 'REGISTERING ACTIONPACK RECIPE'
+      recipe.time :response_time, :method => 'DashAnalyzer::Base#call', :mark => true
+      recipe.time :another_response_time, :method => 'DashAnalyzer::Base#call', :mark => true
+    end
+    
+    def initialize(*)
+      @recipes = [{:name => :testpack, :url => 'http://example.org'}]
+      super
+    end  
+  end
+  
+  def app
+    MyApp.new(FooApp.new, 1)
+  end
+
+  # MAKE SURE MONGO IS RUNNING ON localhost:27017
+  def test_mongodb
+    get "/foo"
+    
+    assert_not_nil app.db
+  end
+
+  def test_success
+    get "/foo"
+    
+    assert last_response.ok?
+  end
+  
+  # Should I really be testing Dash internals? I think not.
+  def x_test_session_data_store
+    5.times do
+      get "/foo"
+    end
+     
+    # Not really sure what this is all about, but I got it to work
+    data = Fiveruns::Dash.session.data
+    
+    assert_equal 5, data.first[:values].first[:invocations]
+    
+    7.times do
+      get "/foo"
+    end
+    
+    # OK. Accessing the session data clears it out.
+    data2 = Fiveruns::Dash.session.data
+    assert_equal 7, data2.first[:values].first[:invocations]
+  end
+  
+  def test_mongo_data_store
+    coll = app.db.collection('testpack-response_time')
+    coll.clear
+    
+    5.times do
+      get "/foo"
+    end
+    
+    sleep Fiveruns::Dash.session.reporter.interval
+    
+    total_invocations = 0
+    
+    coll.find().each do |row|
+      values = row[:values]
+      if values
+        invocations = values[:invocations]
+        total_invocations += invocations
+      end
+    end
+
+    assert 5, total_invocations
+  end
+  
+  def test_mongo_data_store_with_multiple_metrics
+    coll1 = app.db.collection('testpack-response_time')
+    coll1.clear
+    
+    coll2 = app.db.collection('testpack-another_response_time')
+    coll2.clear
+    
+    10.times do
+      get "/foo"
+    end
+    
+    sleep Fiveruns::Dash.session.reporter.interval
+
+    #coll.find().each { |row| puts row.class; puts row.inspect; puts "-------" }
+    
+    total_coll1_invocations = 0
+    
+    coll1.find().each do |row|
+      values = row[:values]
+      if values
+        invocations = values[:invocations]
+        total_coll1_invocations += invocations
+      end
+    end
+    
+    total_coll2_invocations = 0
+    
+    coll2.find().each do |row|
+      values = row[:values]
+      if values
+        invocations = values[:invocations]
+        total_coll2_invocations += invocations
+      end
+    end
+
+    assert 5, total_coll1_invocations
+    assert 5, total_coll2_invocations
+  end
+  
+  # Just trying to ensure Dash is sending info when requests aren't being made
+  def test_frequency_of_mongo_data_inserts
+    coll = app.db.collection('testpack-response_time')
+    coll.clear
+    
+    5.times do
+      get "/foo"
+    end
+    
+    sleep Fiveruns::Dash.session.reporter.interval*20
+
+    assert 20 <= coll.count
+  end
+    
+end

data/test/lib/dash_analyzer/test_dash_extensions.rb

@@ -0,0 +1,7 @@
+# These really need to be run through the ol testers
+
+# require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+# 
+# class DashExtensionsTest < Test::Unit::TestCase
+# 
+# end

data/test/lib/dash_analyzer/test_view.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class ViewTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+  
+  class MyApp < DashAnalyzer::TimeView
+  end
+  
+  def app
+    MyApp.new(FooApp.new, 'testpack-response_time')
+  end
+  
+  def test_index
+    get "/analytics"
+    
+    assert last_response.ok?
+       
+    puts last_response.body
+  end
+  
+  def test_show
+    get "/analytics/show/testpack-response_time"
+    
+    assert last_response.ok?
+  end
+  
+end

data/test/lib/middleware/rails.rb

@@ -0,0 +1,7 @@
+# What goes here?
+# 
+# require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+# 
+# class RailsTest < Test::Unit::TestCase
+# 
+# end

data/test/lib/middleware/rails/dash.rb

@@ -0,0 +1,7 @@
+# What goes here?
+
+# require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+# 
+# class DashTest < Test::Unit::TestCase
+# 
+# end

data/test/lib/test_dash_analyzer.rb

@@ -0,0 +1,7 @@
+# What goes here?
+
+# require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+# 
+# class DashAnalyzerTest < Test::Unit::TestCase
+# 
+# end

data/test/lib/test_middleware.rb

@@ -0,0 +1,7 @@
+# What goes here?
+
+# require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+# 
+# class MiddlewareTest < Test::Unit::TestCase
+# 
+# end

data/test/test_helper.rb

@@ -0,0 +1,23 @@
+require "rubygems" # I know...I know...don't do this
+
+require "test/unit"
+require "autotest"
+
+require "rack/test"
+
+require File.dirname(__FILE__) << "/../lib/abstract_analyzer"
+
+# Create a test mongo db
+test_mongo_db = Mongo::Connection.new('localhost', 27017).db('test-dash-analyzer-db')
+AbstractAnalyzer.const_set("DB", test_mongo_db)
+
+# Create a test log
+test_logger = Logger.new(File.dirname(__FILE__) << "/abstract_analyzer_logger.log")
+AbstractAnalyzer.const_set("LOGGER", test_logger)
+
+# Create a test rack app
+class FooApp
+  def call(env)
+    [200, {"Content-Type" => "text/plain"}, ["Hello world!"]]
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: abstract_analyzer
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Mark McSpadden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-28 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: markmcspadden@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/abstract_analyzer.rb
+- lib/dash_analyzer.rb
+- lib/dash_analyzer/base.rb
+- lib/dash_analyzer/dash_extensions.rb
+- lib/dash_analyzer/view.rb
+- lib/middleware.rb
+- lib/middleware/rails.rb
+- lib/middleware/rails/dash.rb
+- lib/view.rb
+- test/lib/dash_analyzer/test_base.rb
+- test/lib/dash_analyzer/test_dash_extensions.rb
+- test/lib/dash_analyzer/test_view.rb
+- test/lib/middleware/rails.rb
+- test/lib/middleware/rails/dash.rb
+- test/lib/test_dash_analyzer.rb
+- test/lib/test_middleware.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/garlandgroup/abstract-analyzer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A rack based app analyzer
+test_files: 
+- test/lib/dash_analyzer/test_base.rb
+- test/lib/dash_analyzer/test_dash_extensions.rb
+- test/lib/dash_analyzer/test_view.rb
+- test/lib/middleware/rails/dash.rb
+- test/lib/middleware/rails.rb
+- test/lib/test_dash_analyzer.rb
+- test/lib/test_middleware.rb
+- test/test_helper.rb