tuttle 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11308ee417997ed89c1e29539cc8cb0fecf125bc
-  data.tar.gz: 624f021eb368b6bd329771ce1a2af67970622cab
+  metadata.gz: 49cad804b33f2b81f6a9bc6a2e6504e4cf37c962
+  data.tar.gz: e8e15e4dee3836b696168ad3a89b102b4f4af856
 SHA512:
-  metadata.gz: 5b59ac504e78b6e910f5e32808dfda8b9c5908b70fcfc8057a7e488d33604634a67256ea9b514ad421c5c2b833f8e3bfb182bf3963c829eb015a8530139523c4
-  data.tar.gz: 37577b68008df08c28a0355fc2425c4ccbf5b149e7fb126c141eb0750007b8b3d968fb60bb588a8517c7bfcbaa7d6b4b870fce0f6cdbe03457fb6f4a10ecde25
+  metadata.gz: a03f4de6b82666e963e1b6c1b5b4347389e8a2cd5ae00a2ece02953954a84d17fb37668adf43e88a473263cd15780e59afb8adbc66b11e2e1472f89ebb3d54a3
+  data.tar.gz: a8b9074ed5bbcfeae270e7b2ab875710acd826b383e76f3e2169945f23df06c20f542cad4f35821bbcfe88fb902db747110b4da6439fc40e22956365be0a3bf0

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+### 0.0.6
+
+* Features
+  * Easier configuration with config.enable_profiling to load profiling middleware
+  * Improved Asset Pipeline configuration inspector
+  * Improved Rails Caching configuration inspector
+  * Basic ActiveJob configuration inspector
+  * Improved Rails general configuration options from Rails Guides
+  * Syntax highlighting with highlight.js
+  * Experimental inspector for Facter
+  * Experimental profiler for Busted with additional DTrace inspections
+
 ### 0.0.5
 
 * Features

data/README.md

@@ -2,17 +2,74 @@
 
 [![Build Status](https://api.travis-ci.org/dgynn/tuttle.svg?branch=develop)](https://travis-ci.org/dgynn/tuttle)
 [![Code Climate](https://codeclimate.com/github/dgynn/tuttle/badges/gpa.svg)](https://codeclimate.com/github/dgynn/tuttle)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/494ffe3bb99b4d139ca975eaeec72808)](https://www.codacy.com/app/davegynn/tuttle)
 [![Test Coverage](https://codeclimate.com/github/dgynn/tuttle/badges/coverage.svg)](https://codeclimate.com/github/dgynn/tuttle)
 [![Dependency Status](https://gemnasium.com/dgynn/tuttle.svg)](https://gemnasium.com/dgynn/tuttle)
 
-Tuttle is a tool for assisting Rails developers by exposing runtime configuration information for your application. It is similar to the `/rails/info/routes` and `/rails/info/properties` information pages or the `rake routes` and `rake middleware` tasks.
+Tuttle is a tool that helps Rails developers peek behind the curtain to inspect runtime configuration
+information for their applications. Tuttle can help with troubleshooting misconfigured
+apps or just help you better understand what is going on inside the frameworks you use.
 
-Tuttle is very much in alpha/proof-of-concept mode. You can see it in action in a [simple demo application](http://tuttle-demo.herokuapp.com/). The [source code](https://github.com/dgynn/tuttle-demo) for that demo is also on GitHub.
+#### Features
+
+* Web dashboard mounted in your running app
+  * Rails general configuration including defaults
+  * Runtime internals of libraries and frameworks (eg ActiveRecord Query Cache)
+  * Application inventory of Controllers and Models
+  * Gems loaded
+  * Ruby VM runtime information (GC stats, tuning parameters)
+* Optional profiling middleware for on-demand request profiling
+  * Memory profiling using [memory_profiler](https://github.com/SamSaffron/memory_profiler)
+  * CPU profiling using [ruby-prof](https://github.com/ruby-prof/ruby-prof)
+
+
+Tuttle has no dependencies other than Rails but works with a number of gems if
+they are loaded to provide inspections.
+Gems supported include devise, paperclip, active_model_serializers, cancancan, and more.
+
+Tuttle is still in beta/proof-of-concept mode but is safe to use in development and disabled by default in other environments.
+
+You can see it in action in a [simple demo application](http://tuttle-demo.herokuapp.com/). The [source code](https://github.com/dgynn/tuttle-demo) for that demo is also on GitHub.
 
 ## To use...
 
-Add tuttle to you Gemfile
+Add tuttle to your Gemfile
 ```ruby
-gem 'tuttle', :github => 'dgynn/tuttle', :branch => 'develop'
+gem 'tuttle'
+
+# Include optional profiling gems
+gem 'memory_profiler'
+gem 'ruby-prof'
+
 ```
 Browse to `/tuttle`
+
+## Configuration
+
+Tuttle will automatically be enabled and mounted in development. To control the
+configuration, you can use an initializer.
+
+config/initializers/tuttle.rb
+```ruby
+if defined?(::Tuttle::Engine)
+  Tuttle.setup do |config|
+    config.enabled = true           # Defaults to true in development, false in other environments
+    config.automount_engine = true  # Defaults to true to mount the engine at /tuttle
+    config.enable_profiling = true  # Defaults to false
+  end
+end
+```
+
+**Important:** Do not enable Tuttle in production. Tuttle does not require authentication
+and exposes internal application details. Sensitive data should be filtered but
+it is still not something end users should be able to access.
+
+It is also possible to use the profiling middleware without the Tuttle engine enabled.
+
+You can directly include the profiling middleware as follows:
+
+```ruby
+  # Add memory/cpu profiler middleware at the end of the stack
+  require 'tuttle/middleware/request_profiler'
+  Rails.application.config.middleware.use Tuttle::Middleware::RequestProfiler
+```

data/Rakefile

@@ -4,21 +4,6 @@ begin
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
-begin
-  require 'rdoc/task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
-end
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Tuttle'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
 
 APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
 load 'rails/tasks/engine.rake'
@@ -28,10 +13,10 @@ Bundler::GemHelper.install_tasks
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
+  t.warning = false
 end
 
 task :default => :test

data/app/controllers/tuttle/active_job_controller.rb

@@ -0,0 +1,51 @@
+require_dependency 'tuttle/application_controller'
+
+module Tuttle
+  class ActiveJobController < ApplicationController
+
+    def index
+      @job_classes = ActiveJob::Base.descendants # May want to not includ ApplicationJob if it exists
+
+      # TODO: could also look to see if GlobalID is available
+      # https://github.com/rails/globalid
+
+      # See http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html
+
+      # TODO: detect available backend libraries
+      # TODO: catalog the .descendants of ActiveJob::Base
+      #   - list the queue_name and queue_adapter per job
+
+      # == Active Job adapters
+      #
+      # Active Job has adapters for the following queueing backends:
+      #
+      # * {Backburner}[https://github.com/nesquena/backburner]
+      # * {Delayed Job}[https://github.com/collectiveidea/delayed_job]
+      # * {Qu}[https://github.com/bkeepers/qu]
+      # * {Que}[https://github.com/chanks/que]
+      # * {queue_classic}[https://github.com/QueueClassic/queue_classic]
+      # * {Resque 1.x}[https://github.com/resque/resque/tree/1-x-stable]
+      # * {Sidekiq}[http://sidekiq.org]
+      # * {Sneakers}[https://github.com/jondot/sneakers]
+      # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
+      # * {Active Job Async Job}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
+      # * {Active Job Inline}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+      #
+      # === Backends Features
+      #
+      #   |                   | Async | Queues | Delayed    | Priorities | Timeout | Retries |
+      #   |-------------------|-------|--------|------------|------------|---------|---------|
+      #   | Backburner        | Yes   | Yes    | Yes        | Yes        | Job     | Global  |
+      #   | Delayed Job       | Yes   | Yes    | Yes        | Job        | Global  | Global  |
+      #   | Qu                | Yes   | Yes    | No         | No         | No      | Global  |
+      #   | Que               | Yes   | Yes    | Yes        | Job        | No      | Job     |
+      #   | queue_classic     | Yes   | Yes    | Yes*       | No         | No      | No      |
+      #   | Resque            | Yes   | Yes    | Yes (Gem)  | Queue      | Global  | Yes     |
+      #   | Sidekiq           | Yes   | Yes    | Yes        | Queue      | No      | Job     |
+      #   | Sneakers          | Yes   | Yes    | No         | Queue      | Queue   | No      |
+      #   | Sucker Punch      | Yes   | Yes    | Yes        | No         | No      | No      |
+      #   | Active Job Async  | Yes   | Yes    | Yes        | No         | No      | No      |
+      #   | Active Job Inline | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
+    end
+  end
+end

data/app/controllers/tuttle/active_model_serializers_controller.rb

@@ -10,16 +10,11 @@ module Tuttle
       @serializers = ::ActiveModel::Serializer.descendants
       @serializers.sort_by!(&:name)
 
-      @adapter_map = if ActiveModel::Serializer::Adapter.const_defined?(:ADAPTER_MAP)
-                       ActiveModel::Serializer::Adapter.const_get(:ADAPTER_MAP)
-                     else
-                       ActiveModelSerializers::Adapter.const_get(:ADAPTER_MAP)
-                     end
-
-      unless defined?(ActiveModelSerializers)
+      if defined?(ActiveModelSerializers)
+        render 'index'
+      else
         render 'index9'
       end
-
     end
 
   end

data/app/controllers/tuttle/application_controller.rb

@@ -1,9 +1,12 @@
 module Tuttle
   class ApplicationController < ActionController::Base
     abstract!
+    protect_from_forgery with: :exception
 
     before_action :check_reload_status
 
+    private
+
     def check_reload_status
       return unless Tuttle::Engine.reload_needed && !Rails.configuration.eager_load
       Tuttle::Engine.logger.warn('Eager-loading application')

data/app/controllers/tuttle/cancancan_controller.rb

@@ -9,25 +9,18 @@ module Tuttle
     end
 
     def rule_tester
-      @models = ActiveRecord::Base.descendants
+      @models = ActiveRecord::Base.descendants.reject(&:abstract_class)
       @action = params[:action_name] || 'read'
-      @subject = nil
-
-      subject_class = params[:subject_class]
-      subject_id = params[:subject_id]
-
-      if !subject_class.blank? && Kernel.const_defined?(subject_class)
-        begin
-          subject_klass = Kernel.const_get(params[:subject_class])
-          @subject = subject_klass.find(subject_id) unless subject_id.blank?
-          @subject ||= subject_klass.new
-        rescue
-          # Could not load subject
-        end
-      end
+      @subject = find_subject(params[:subject_class], params[:subject_id])
       @cancan_user = current_user || User.new
       @ability = Ability.new(@cancan_user)
     end
 
+    private
+
+    def find_subject(subject_class, subject_id)
+      subject_klass = @models.detect { |x| x.name == subject_class } if subject_class.present?
+      subject_klass.find_or_initialize_by(:id => subject_id) if subject_klass
+    end
   end
 end

data/app/controllers/tuttle/devise_controller.rb

@@ -1,11 +1,10 @@
 require_dependency 'tuttle/application_controller'
-require 'devise/version' if defined? Devise
+require 'devise/version' if defined?(Devise)
 
 module Tuttle
   class DeviseController < ApplicationController
 
     def index
-      render(plain: "Devise not installed") and return unless defined? ::Devise
     end
 
   end

data/app/controllers/tuttle/gems_controller.rb

@@ -4,23 +4,23 @@ module Tuttle
   class GemsController < ApplicationController
 
     def index
-
     end
 
     def http_clients
-
     end
 
     def json
-
     end
 
+    # rubocop:disable Style/AccessorMethodName
     def get_process_mem
+      require 'get_process_mem'
       require 'get_process_mem/version'
+      @memory_self = GetProcessMem.new
+      @memory_parent = GetProcessMem.new(Process.ppid)
     end
 
     def other
-
     end
 
   end

data/app/controllers/tuttle/home_controller.rb

@@ -5,7 +5,6 @@ module Tuttle
   class HomeController < ApplicationController
 
     def index
-      @event_counts = Tuttle::Instrumenter.event_counts
     end
 
   end

data/app/controllers/tuttle/paperclip_controller.rb

@@ -1,12 +1,11 @@
 require_dependency 'tuttle/application_controller'
-require 'paperclip/version' if defined?(::Paperclip)
+require 'paperclip/version' if defined?(Paperclip)
 
 module Tuttle
   class PaperclipController < ApplicationController
 
     def index
       # Note: in development with reloading, classes will show up in the registry multiple times
-      render(plain: "Paperclip not installed") and return unless defined?(::Paperclip)
       @pcar = Paperclip::AttachmentRegistry.instance
     end
 

data/app/controllers/tuttle/rack_mini_profiler_controller.rb

@@ -0,0 +1,15 @@
+require_dependency 'tuttle/application_controller'
+
+module Tuttle
+  class RackMiniProfilerController < ApplicationController
+
+    def index
+      return redirect_to gems_other_path unless defined?(::Rack::MiniProfiler::Config)
+
+      require_dependency 'tuttle/presenters/rack_mini_profiler/client_settings'
+      @mp_config = ::Rack::MiniProfiler.config
+      @mp_client_settings = Tuttle::Presenters::RackMiniProfiler::ClientSettings.new(request.env)
+    end
+
+  end
+end

data/app/controllers/tuttle/rails_controller.rb

@@ -6,6 +6,7 @@ module Tuttle
   class RailsController < ApplicationController
 
     def index
+      @config_options = Tuttle::ConfigurationRegistry.data.to_a.sort_by!(&:first)
     end
 
     def controllers
@@ -34,6 +35,7 @@ module Tuttle
 
     def database
       @conn = ActiveRecord::Base.connection
+      @data_sources = @conn.respond_to?(:data_sources) ? @conn.data_sources : @conn.tables
     end
 
     def schema_cache
@@ -59,11 +61,12 @@ module Tuttle
       # helper_symbol = Rails.application.helpers.instance_methods.first
       # Rails.application.helpers.instance_method(helper_symbol).owner
       # Rails.application.helpers.instance_method(helper_symbol).parameters
-      @helpers = ::ApplicationController.send(:modules_for_helpers,[:all])
+      @helpers = ::ApplicationController.send(:modules_for_helpers, [:all])
     end
 
     def assets
-      @sprockets = Rails.application.assets
+      @sprockets_env = Rails.application.assets
+      @assets_config = Rails.application.config.assets
       # TODO: revisit detection of "engines" which are classified as processors, transformers, etc.
     end
 
@@ -71,6 +74,10 @@ module Tuttle
       @routes = Rails.application.routes.routes.collect do |route|
         Tuttle::Presenters::ActionDispatch::Routing::RouteWrapper.new(route)
       end
+      if params[:recognize_path]
+        @path_to_recognize = params[:recognize_path]
+        @recognized_paths = recognize_paths(params[:recognize_path])
+      end
       # TODO: include engine-mounted routes
     end
 
@@ -80,14 +87,45 @@ module Tuttle
     end
 
     def cache
+      @cache = Rails.cache
       # TODO: make cache instrumentation controllable - this will automatically turn in on in Rails < 4.2
       # Instrumentation is always on in Rails 4.2+
-      if Rails::VERSION::STRING =~ /^4\.1\./ && !ActiveSupport::Cache::Store.instrument
-        ActiveSupport::Cache::Store.instrument=true
+      # if Rails::VERSION::STRING =~ /^4\.1\./ && !ActiveSupport::Cache::Store.instrument
+      #   ActiveSupport::Cache::Store.instrument = true
+      # end
+      # @cache_events = Tuttle::Instrumenter.events.select {|e| /cache_(read|write)\.active_support/ =~ e.name }
+      # @tuttle_cache_events = Tuttle::Instrumenter.cache_events
+    end
+
+    private
+
+    def recognize_paths(path)
+      results = {}
+      [:get, :post, :put, :delete, :patch].each {|method| results[method] = recognize_path(path, method: method)}
+      results
+    end
+
+    # a version that handles engines - based on https://gist.github.com/jtanium/6114632
+    # it's possible that multiple engines could handle a particular path.  So we will
+    # capture each of them
+    def recognize_path(path, options)
+      recognized_paths = []
+      recognized_paths << Rails.application.routes.recognize_path(path, options)
+    rescue ActionController::RoutingError => exception
+      # The main app didn't recognize the path, try the engines...
+      Rails::Engine.subclasses.each do |engine|
+        engine_instance = engine.instance
+        engine_class = engine_instance.class
+        begin
+          recognized_path = engine_instance.routes.recognize_path(path, options)
+          recognized_path[:engine] = engine_class
+          recognized_paths << recognized_path
+        rescue ActionController::RoutingError
+          Tuttle::Engine.logger.info("Routing error recognizing path for #{path}")
+        end
       end
-      @cache = Rails.cache
-      @cache_events = Tuttle::Instrumenter.events.select {|e| /cache_(read|write)\.active_support/ =~ e.name }
-      @tuttle_cache_events = Tuttle::Instrumenter.cache_events
+
+      recognized_paths.empty? ? [{ error: exception.message }] : recognized_paths
     end
 
   end

data/app/controllers/tuttle/request_controller.rb

@@ -10,7 +10,3 @@ module Tuttle
 
   end
 end
-
-
-
-

data/app/controllers/tuttle/ruby_controller.rb

@@ -5,15 +5,20 @@ require_dependency 'tuttle/application_controller'
 module Tuttle
   class RubyController < ApplicationController
 
+    ENV_FILTERS = [/.*_(URL|PASSWORD|KEY|KEY_BASE|AUTHENTICATION)$/].freeze
+
     def index
       # TODO: need better filter for sensitive values. this covers DB-style URLs with passwords, passwords, and keys
-      @filtered_env = ENV.to_hash.tap{ |h| h.each{ |k,_v| h[k] = '--FILTERED--' if /.*_(URL|PASSWORD|KEY|KEY_BASE)$/ =~ k  } }
+      env_hash = ENV.to_hash
+      env_hash = ActionDispatch::Http::ParameterFilter.new(ENV_FILTERS).filter(env_hash) unless params[:nofilter]
+      @filtered_env = env_hash.sort
     end
 
     def tuning
       @gc_enabled = (GC.disable ? false : GC.enable)
 
       # taken verbatim from the ruby 2.2 man page
+      # rubocop:disable Metrics/LineLength
       @gc_params = {
         'RUBY_GC_HEAP_INIT_SLOTS' =>               'Initial allocation slots.  Introduced in Ruby 2.1, default: 10000.',
         'RUBY_GC_HEAP_FREE_SLOTS' =>               'Prepare at least this amount of slots after GC. Allocate this number slots if there are not enough slots.  Introduced in Ruby 2.1, default: 4096',
@@ -30,7 +35,6 @@ module Tuttle
     end
 
     def miscellaneous
-
     end
 
   end