tcell_agent 0.2.7 → 0.2.8

data/lib/tcell_agent/rails/middleware/body_filter_middleware.rb

@@ -74,7 +74,8 @@ module TCellAgent
                       script_tag_policy.js_agent_api_key)
                     newbody = []
                     rack_body.each { |str| 
-                      newbody << self.replace_in_body(script_tag_policy, str) 
+                      newbody_part = self.replace_in_body(script_tag_policy, str) || str
+                      newbody << newbody_part
                     }
                     response = [status, headers, newbody]
                   end

data/lib/tcell_agent/rails/on_start.rb

@@ -1,101 +1,99 @@
 # See the file "LICENSE" for the full license governing this code.
 
 #require 'tcell_agent/authlogic' if defined?(Authlogic)
-#require 'tcell_agent/devise' if defined?(Devise)
+require 'tcell_agent/configuration'
 
 require 'rails/all'
+require 'rails'
 
-module TCellAgent
-  module Instrumentation
-    module Rails
-      METHODS = ['GET','POST','PUT','DELETE','HEAD',
-                 'PATCH','TRACE','CONNECT','OPTIONS']
-
-      def self.instrument_route(route)
-        if (route.constraints.has_key? :request_method)
-          route_path = "#{route.path.spec}"
-          if (route_path.end_with?("(.:format)"))
-            route_path = route_path.chomp("(.:format)")
-          end
+TCellAgent::Instrumentation::Rails.send_language_info
+TCellAgent::Instrumentation::Rails.send_framework_info 
+if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? 
+  module TCellAgent
+    module Instrumentation
+      module Rails
+        METHODS = ['GET','POST','PUT','DELETE','HEAD',
+                   'PATCH','TRACE','CONNECT','OPTIONS']
+
+        def self.instrument_route(route)
+          if (route.constraints.has_key? :request_method)
+            route_path = "#{route.path.spec}"
+            if (route_path.end_with?("(.:format)"))
+              route_path = route_path.chomp("(.:format)")
+            end
 
-          route_destination = route.defaults.to_json.to_s
+            route_destination = route.defaults.to_json.to_s
 
-          route_methods = METHODS.select { |x| route.verb.match(x) }
-          route_methods.each { |route_method|
-            route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, route.path.spec)
-            TCellAgent.send_event(
-              TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
-                route_path, route_method, route_id, nil, route_destination
+            route_methods = METHODS.select { |x| route.verb.match(x) }
+            route_methods.each { |route_method|
+              route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, route.path.spec)
+              TCellAgent.send_event(
+                TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
+                  route_path, route_method, route_id, nil, route_destination
+                )
               )
-            )
-          }
+            }
+          end
         end
-      end
 
-      def self.instrument_routes
-        if ::Rails.application
-          ::Rails.application.routes.routes.each do |route|
-            self.instrument_route(route)
+        def self.instrument_routes
+          if ::Rails.application
+            ::Rails.application.routes.routes.each do |route|
+              self.instrument_route(route)
+            end
           end
         end
-      end
 
-      if (::Rails::VERSION::MAJOR == 3)
-        ActionDispatch::Routing::RouteSet.class_eval do
-            alias_method :original_add_route, :add_route
-            def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
-              route = original_add_route(app, conditions, requirements, defaults, name, anchor)
+        if (::Rails::VERSION::MAJOR == 3)
+          ActionDispatch::Routing::RouteSet.class_eval do
+              alias_method :original_add_route, :add_route
+              def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
+                route = original_add_route(app, conditions, requirements, defaults, name, anchor)
 
-              TCellAgent::Instrumentation::Rails.instrument_route(route)
+                TCellAgent::Instrumentation::Rails.instrument_route(route)
 
-              route
-            end
+                route
+              end
+          end
         end
-      end
 
-      if (::Rails::VERSION::MAJOR == 4)
-        ActionDispatch::Journey::Routes.class_eval do
-          alias_method :original_add_route, :add_route
-          def add_route(app, path, conditions, defaults, name = nil)
-            route = original_add_route(app, path, conditions, defaults, name)
+        if (::Rails::VERSION::MAJOR == 4)
+          ActionDispatch::Journey::Routes.class_eval do
+            alias_method :original_add_route, :add_route
+            def add_route(app, path, conditions, defaults, name = nil)
+              route = original_add_route(app, path, conditions, defaults, name)
 
-            TCellAgent::Instrumentation::Rails.instrument_route(route)
+              TCellAgent::Instrumentation::Rails.instrument_route(route)
 
-            route
+              route
+            end
           end
         end
-      end
 
+      end
     end
   end
-end
 
+  if (Rails.application)
+    TCellAgent::Instrumentation::Rails.send_settings(Rails.application)
+  else
+    module TCellAgent
+      class MyRailtie < Rails::Railtie
+        initializer 'activeservice.autoload', :after => :set_autoload_paths do |app|
+          if (TCellAgent.configuration.enabled)
+            Rails.application.config.to_prepare do
+              require 'tcell_agent/devise' if defined?(Devise)
+              require 'tcell_agent/rails/auth/devise' if defined?(Devise)
+              require 'tcell_agent/authlogic' if defined?(Authlogic)
+              require 'tcell_agent/rails/auth/authlogic'  if defined?(Authlogic)
+            end
 
-TCellAgent::Instrumentation::Rails.send_framework_info
-if (Rails.application)
-  TCellAgent::Instrumentation::Rails.send_settings(Rails.application)
-  require 'tcell_agent/devise' if defined?(Devise)
-  require 'tcell_agent/rails/auth/devise' if defined?(Devise)
-  require 'tcell_agent/authlogic' if defined?(Authlogic)
-  require 'tcell_agent/rails/auth/authlogic'  if defined?(Authlogic)
-
-else
-  module TCellAgent
-    class MyRailtie < Rails::Railtie
-      initializer 'activeservice.autoload', :after => :set_autoload_paths do |app|
-        if (TCellAgent.configuration.enabled)
-          Rails.application.config.to_prepare do
-            require 'tcell_agent/devise' if defined?(Devise)
-            require 'tcell_agent/rails/auth/devise' if defined?(Devise)
-            require 'tcell_agent/authlogic' if defined?(Authlogic)
-            require 'tcell_agent/rails/auth/authlogic'  if defined?(Authlogic)
-          end
-
-          Rails.application.config.after_initialize do
-            TCellAgent::Instrumentation::Rails.send_settings(Rails.application)
+            Rails.application.config.after_initialize do
+              TCellAgent::Instrumentation::Rails.send_settings(Rails.application)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/tcell_agent/rails/routes.rb

@@ -1,99 +1,104 @@
-module TCellAgent
-  ActiveSupport.on_load(:action_controller) do
-    ActionController::Base.class_eval do
+require 'tcell_agent/configuration'
 
-      prepend_around_filter :tell_around_filter_routes
-      def tell_around_filter_routes
-        begin
-          TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") {
-            route = Rails.application.routes.router.recognize(request) { |r, _| r }.first
-            if route
-              route_path = route[2].path.spec
-              tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-              if tcell_context
-                tcell_context.route_id = TCellAgent::SensorEvents::Util.calculateRouteId(request.method.downcase, route_path)
+if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? && TCellAgent.configuration.should_intercept_requests?
+
+  module TCellAgent
+    ActiveSupport.on_load(:action_controller) do
+      ActionController::Base.class_eval do
+
+        prepend_around_filter :tell_around_filter_routes
+        def tell_around_filter_routes
+          begin
+            TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") {
+              route = Rails.application.routes.router.recognize(request) { |r, _| r }.first
+              if route
+                route_path = route[2].path.spec
+                tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
+                if tcell_context
+                  tcell_context.route_id = TCellAgent::SensorEvents::Util.calculateRouteId(request.method.downcase, route_path)
+                end
               end
-            end
-          }
-              def loop_params_hash(method, param_hash, prefix, &block)
-                  param_hash.each do |param_name, param_value|
-                      if param_value && param_value.is_a?(Hash)
-                          loop_params_hash(method, param_value, 'hash', &block)
-                      elsif !param_value || !param_value.instance_of?(String) || param_value == ""
-                          next
-                      else
-                          block.call(method, param_name, param_value)
+            }
+                def loop_params_hash(method, param_hash, prefix, &block)
+                    param_hash.each do |param_name, param_value|
+                        if param_value && param_value.is_a?(Hash)
+                            loop_params_hash(method, param_value, 'hash', &block)
+                        elsif !param_value || !param_value.instance_of?(String) || param_value == ""
+                            next
+                        else
+                            block.call(method, param_name, param_value)
+                        end
+                    end
+                end
+                def for_params(request, &block)
+                    get_params = request.GET
+                    if get_params
+                      self.loop_params_hash('get', get_params, nil, &block)
+                    end
+                    post_params = request.POST
+                    if post_params
+                      self.loop_params_hash('post', post_params, nil, &block)
+                    end
+                end
+                def _handle_dataexpsure_forms(request)
+                  dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+                  tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
+                  if tcell_context && dataex_policy && dataex_policy.has_actions_for_form_parameter?
+                    for_params(request) { |method, param_name, param_value|
+                      actions = dataex_policy.get_actions_for_request("form",param_name)
+                      if actions
+                        actions.each { |action|
+                          tcell_context.add_filter_for_request_parameter(param_value, action, param_name)
+                        }
                       end
+                    }
                   end
-              end
-              def for_params(request, &block)
-                  get_params = request.GET
-                  if get_params
-                    self.loop_params_hash('get', get_params, nil, &block)
-                  end
-                  post_params = request.POST
-                  if post_params
-                    self.loop_params_hash('post', post_params, nil, &block)
-                  end
-              end
-              def _handle_dataexpsure_forms(request)
-                dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-                tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-                if tcell_context && dataex_policy && dataex_policy.has_actions_for_form_parameter?
-                  for_params(request) { |method, param_name, param_value|
-                    actions = dataex_policy.get_actions_for_request("form",param_name)
-                    if actions
-                      actions.each { |action|
-                        tcell_context.add_filter_for_request_parameter(param_value, action, param_name)
-                      }
-                    end
-                  }
                 end
-              end
-              TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request forms)") {
-                _handle_dataexpsure_forms(request)
-              }
+                TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request forms)") {
+                  _handle_dataexpsure_forms(request)
+                }
 
-              def _handle_dataexpsure_headers(request)
-                dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-                tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-                if tcell_context && dataex_policy && dataex_policy.has_actions_for_headers?
-                  headers = request.env.select {|k,v| k.start_with? 'HTTP_'}
-                  headers.each { |header_name, header_value|
-                    header_name = header_name.sub(/^HTTP_/, '').gsub('_','-')
-                    actions = dataex_policy.get_actions_for_header(header_name)
-                    if actions
-                      actions.each { |action|
-                        tcell_context.add_filter_for_header_value(header_value, action, header_name)
-                      }
-                    end
-                  }
+                def _handle_dataexpsure_headers(request)
+                  dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+                  tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
+                  if tcell_context && dataex_policy && dataex_policy.has_actions_for_headers?
+                    headers = request.env.select {|k,v| k.start_with? 'HTTP_'}
+                    headers.each { |header_name, header_value|
+                      header_name = header_name.sub(/^HTTP_/, '').gsub('_','-')
+                      actions = dataex_policy.get_actions_for_header(header_name)
+                      if actions
+                        actions.each { |action|
+                          tcell_context.add_filter_for_header_value(header_value, action, header_name)
+                        }
+                      end
+                    }
+                  end
                 end
-              end
-              TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request headers)") {
-                _handle_dataexpsure_headers(request)
-              }
+                TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request headers)") {
+                  _handle_dataexpsure_headers(request)
+                }
 
-              def _handler_dataexposure_cookies(request)
-                dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-                tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]               
-                if tcell_context && dataex_policy && dataex_policy.has_actions_for_cookie?
-                  request.cookies.each { |cookie_name, cookie_value|
-                    actions = dataex_policy.get_actions_for_cookie(cookie_name)
-                    if actions
-                      actions.each { |action|
-                        tcell_context.add_filter_for_cookie_value(cookie_value, action, cookie_name)
-                      }
-                    end
-                  }
+                def _handler_dataexposure_cookies(request)
+                  dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+                  tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]               
+                  if tcell_context && dataex_policy && dataex_policy.has_actions_for_cookie?
+                    request.cookies.each { |cookie_name, cookie_value|
+                      actions = dataex_policy.get_actions_for_cookie(cookie_name)
+                      if actions
+                        actions.each { |action|
+                          tcell_context.add_filter_for_cookie_value(cookie_value, action, cookie_name)
+                        }
+                      end
+                    }
+                  end
                 end
-              end
-              TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request cookies)") {
-                _handler_dataexposure_cookies(request)
-              }
-          yield
+                TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request cookies)") {
+                  _handler_dataexposure_cookies(request)
+                }
+            yield
+          end
         end
       end
     end
   end
-end
+end

data/lib/tcell_agent/rails/settings_reporter.rb

@@ -2,6 +2,7 @@ require 'rails'
 require 'tcell_agent'
 require 'tcell_agent/sensor_events/app_config'
 require 'tcell_agent/sensor_events/server_agent'
+require 'tcell_agent/system_info'
 
 module TCellAgent
   module Instrumentation
@@ -14,6 +15,15 @@ module TCellAgent
                     ))
         end
       end
+      def self.send_language_info
+        if (TCellAgent.configuration.exp_config_settings)
+          language = TCellAgent::SystemInfo.get_language
+          language_version = TCellAgent::SystemInfo.get_language_version
+          TCellAgent.send_event(TCellAgent::SensorEvents::ServerAgentDetailsLanguageEvent.new(
+                      language, language_version
+                    ))          
+        end
+      end
       def self.send_settings(application)
         if (TCellAgent.configuration.exp_config_settings)
           # Defaults to true

data/lib/tcell_agent/routes/table.rb

@@ -10,7 +10,9 @@ module TCellAgent
 
   	class RouteEndpoint
 	    attr_accessor :database
+        attr_accessor :database_queries_discovered
 	    def initialize
+            @database_queries_discovered = {}
 	    	@database = Hash.new {|h,k| # Database
 							h[k] = Hash.new {|h,k| # Schema
 								h[k] = Hash.new {|h,k| # Table

data/lib/tcell_agent/sensor_events/server_agent.rb

@@ -41,6 +41,16 @@ module TCellAgent
                 end
             end
         end
+        class ServerAgentDetailsLanguageEvent < TCellSensorEvent
+            def initialize(language, language_version)
+                super("server_agent_details")
+                @flush = true
+                @ensure = true
+                self["language"] = language
+                self["language_version"] = language_version
+            end
+        end
+
         class ServerAgentAppFrameworkEvent < TCellSensorEvent
             def initialize(framework_name, framework_version)
                 super("server_agent_details")

data/lib/tcell_agent/servers/thin.rb

@@ -1,3 +1,4 @@
+
 Thin::Server.class_eval do
 
   alias_method :original_start, :start

data/lib/tcell_agent/servers/webrick.rb

@@ -10,4 +10,3 @@ Rack::Handler::WEBrick.class_eval do
   end
 
 end
-

data/lib/tcell_agent/start_background_thread.rb

@@ -5,74 +5,73 @@ require 'tcell_agent/agent'
 require 'tcell_agent/configuration'
 require 'thread'
 
-
-module TCellAgent
-
-  if (TCellAgent.configuration.enabled && TCellAgent.configuration.instrument_for_events)
-    require 'tcell_agent/sinatra' if defined?(Sinatra)
+if TCellAgent.configuration.enabled
+  module TCellAgent
+    #require 'tcell_agent/sinatra' if defined?(Sinatra)
     require 'tcell_agent/rails' if defined?(Rails)
-  end
 
-  def self.run_instrumentation(server_name)
-    require 'tcell_agent/rails/on_start' if defined?(Rails)
+    def self.run_instrumentation(server_name)
 
-    begin
-      TCellAgent.logger.debug("Instrumenting: #{server_name}")
-      TCellAgent.thread_agent.start
-    rescue Exception => e
-      TCellAgent.logger.error("Could not start thread agent. #{e.message}")
-    end
+      require 'tcell_agent/rails/on_start' if defined?(Rails)
 
-    Thread.abort_on_exception = TCellAgent.configuration.raise_exceptions
-    Thread.new do
-
-      TCellAgent::Instrumentation.safe_block("Instrumenting Agent Details") do
-        event = TCellAgent::SensorEvents::ServerAgentDetailsSensorEvent.new
-        TCellAgent.send_event(event)
+      begin
+        TCellAgent.logger.debug("Instrumenting: #{server_name}")
+        TCellAgent.thread_agent.start
+      rescue Exception => e
+        TCellAgent.logger.error("Could not start thread agent. #{e.message}")
       end
 
-      TCellAgent::Instrumentation.safe_block("Instrumenting Server Packages") do
-        event = TCellAgent::SensorEvents::ServerAgentPackagesSensorEvent.new
-        TCellAgent.send_event(event)
-      end
+      Thread.abort_on_exception = TCellAgent.configuration.raise_exceptions
+      Thread.new do
+
+        TCellAgent::Instrumentation.safe_block("Instrumenting Agent Details") do
+          event = TCellAgent::SensorEvents::ServerAgentDetailsSensorEvent.new
+          TCellAgent.send_event(event)
+        end
+
+        TCellAgent::Instrumentation.safe_block("Instrumenting Server Packages") do
+          event = TCellAgent::SensorEvents::ServerAgentPackagesSensorEvent.new
+          TCellAgent.send_event(event)
+        end
 
-      if (TCellAgent.configuration.enabled && TCellAgent.configuration.instrument_for_events && defined?(Rails))
-        TCellAgent::Instrumentation.safe_block("Instrumenting routes") do
-          TCellAgent::Instrumentation::Rails.instrument_routes
+        if (TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? && defined?(Rails))
+          TCellAgent::Instrumentation.safe_block("Instrumenting routes") do
+            TCellAgent::Instrumentation::Rails.instrument_routes
+          end
         end
+
       end
 
     end
 
   end
 
-end
-
-tcell_server = ENV["TCELL_AGENT_SERVER"]
+  tcell_server = ENV["TCELL_AGENT_SERVER"]
 
-if (!(tcell_server && tcell_server == "mock"))
+  if (!(tcell_server && tcell_server == "mock"))
 
-  if (tcell_server && tcell_server == "webrick") || defined?(Rails::Server)
+    if (tcell_server && tcell_server == "webrick") || defined?(Rails::Server)
 
-    require("tcell_agent/servers/rails_server")
+      require("tcell_agent/servers/rails_server")
 
-  elsif (tcell_server && tcell_server == "thin") || defined?(Thin)
+    elsif (tcell_server && tcell_server == "thin") || defined?(Thin)
 
-    require("tcell_agent/servers/thin")
+      require("tcell_agent/servers/thin")
 
-  elsif (tcell_server && tcell_server == "puma") || defined?(Puma)
+    elsif (tcell_server && tcell_server == "puma") || defined?(Puma)
 
-    require("tcell_agent/servers/puma")
+      require("tcell_agent/servers/puma")
 
-  elsif (tcell_server && tcell_server == "unicorn") || defined?(Unicorn)
+    elsif (tcell_server && tcell_server == "unicorn") || defined?(Unicorn)
 
-    require("tcell_agent/servers/unicorn")
+      require("tcell_agent/servers/unicorn")
 
-  else
-    puts "[tCell.io] **********************************************************************"
-    puts "[tCell.io] Server used to launch rails not recognized."
-    puts "[tCell.io] You can override this with the env variable"
-    puts "[tCell.io]       TCELL_AGENT_SERVER=thin|puma|unicorn"
-    puts "[tCell.io] **********************************************************************"
+    else
+      puts "[tCell.io] **********************************************************************"
+      puts "[tCell.io] Server used to launch rails not recognized."
+      puts "[tCell.io] You can override this with the env variable"
+      puts "[tCell.io]       TCELL_AGENT_SERVER=thin|puma|unicorn"
+      puts "[tCell.io] **********************************************************************"
+    end
   end
 end