tcell_agent 0.2.21 → 0.2.22

data/lib/tcell_agent/rails/routes.rb

@@ -1,108 +1,267 @@
 require 'tcell_agent/configuration'
+require 'tcell_agent/patches'
+require 'tcell_agent/patches/meta_data'
+require 'tcell_agent/rails/routes/grape'
+require 'tcell_agent/rails/routes/route_id'
+
+require 'json'
 
 module TCellAgent
-  module AroundFilters
-    def self.handle_request_dlp_parameters(request)
-      def self.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
+  module Instrumentation
+
+    module Rails
+
+      class TCellRoute
+        attr_reader :route_id, :route_path, :route_path_raw, :route_destination
+
+        def initialize(route = nil)
+          @route = route
+
+          @route_path_raw = nil
+          @route_path = nil
+          @route_destination = nil
+
+          if route
+            @route_path_raw = route.path.spec.to_s
+
+            @route_path = @route_path_raw
+            @route_path = @route_path_raw.chomp("(.:format)")
+
+            @route_destination = nil
+            if @route.defaults
+              @route_destination = JSON.dump(@route.defaults)
+            end
+          end
+        end
+
+        def report?
+          false
+        end
+
+        def grape_routes
+          []
+        end
+
+        def grape_route?
+          TCellAgent::Instrumentation::grape_route?(@route)
+        end
+
+      end
+
+      class TCellRoute5 < TCellRoute
+
+        def report?
+          TCellAgent::Utils::Strings.present?(@route.verb) || grape_route?
+        end
+
+        def route_methods
+          (@route.verb || "").split('|')
+        end
+
+        def grape_routes
+          @route.app.app.routes
+        end
+
+      end
+
+      class TCellRoute4 < TCellRoute
+        METHODS = %w{ DELETE GET HEAD OPTIONS PATCH POST PUT TRACE CONNECT }
+
+        def report?
+          @route.constraints.has_key?(:request_method) || grape_route?
+        end
+
+        def route_methods
+          METHODS.select { |x| @route.verb.match(x) }
+        end
+
+        def grape_routes
+          if ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR < 2
+            @route.app.routes
           else
-            block.call(method, param_name, param_value)
+            @route.app.app.routes
+          end
+        end
+      end
+
+      def self.create_tcell_route(route)
+        if route
+          if ::Rails::VERSION::MAJOR == 5
+            return TCellRoute5.new(route)
+          elsif ::Rails::VERSION::MAJOR < 5
+            return TCellRoute4.new(route)
+          end
+        end
+
+        TCellRoute.new
+      end
+
+      def self.instrument_routes
+        if ::Rails.application
+          ::Rails.application.routes.routes.each do |route|
+            self.instrument_route(route)
+          end
+        end
+      end
+
+      def self.instrument_route(route)
+        if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument?
+          tcell_route = create_tcell_route(route)
+
+          if tcell_route.report?
+            if tcell_route.grape_route?
+              TCellAgent::Instrumentation.instrument_grape_api(tcell_route.route_path, tcell_route.grape_routes)
+
+            else
+              tcell_route.route_methods.each do |route_method|
+                route_id =
+                  TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, tcell_route.route_path_raw)
+                TCellAgent.send_event(
+                  TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
+                    tcell_route.route_path, route_method, route_id, nil, tcell_route.route_destination
+                  )
+                )
+              end
+            end
           end
         end
       end
-      def self.for_params(request, &block)
-        get_params = request.GET
-        if get_params
-          self.loop_params_hash('get', get_params, nil, &block)
+
+      if (::Rails::VERSION::MAJOR == 3)
+        ActionDispatch::Routing::RouteSet.class_eval do
+          alias_method :tcell_add_route, :add_route
+          def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
+            route = tcell_add_route(app, conditions, requirements, defaults, name, anchor)
+
+            TCellAgent::Instrumentation::Rails.instrument_route(route)
+
+            route
+          end
         end
-        post_params = request.POST
-        if post_params
-          self.loop_params_hash('post', post_params, nil, &block)
+
+        ActiveSupport.on_load(:action_controller) do
+          ActionController::Base.class_eval do
+
+            if (::Rails::VERSION::MAJOR == 5)
+              prepend_around_action :tcell_around_filter_routes
+            elsif (::Rails::VERSION::MAJOR < 5)
+              prepend_around_filter :tcell_around_filter_routes
+            end
+            def tcell_around_filter_routes
+              begin
+
+                if TCellAgent.configuration.enabled &&
+                    TCellAgent.configuration.should_instrument? &&
+                    TCellAgent.configuration.should_intercept_requests?
+                  TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
+                    match, parameters, route = ::Rails.application.routes.router.recognize(request) { |r, _| r }.first
+
+                    TCellAgent::Instrumentation::RouteId.update_context(env, parameters, route)
+                  end
+
+                  patches_response = TCellAgent::Instrumentation::Patches.block?(request)
+                  if patches_response
+                    return head(patches_response)
+                  end
+
+                  TCellAgent::DLP.handle_request_dlp_parameters(request)
+                end
+
+                yield
+              end
+            end
+          end
         end
+
       end
-      def self._handle_dataexpsure_forms(request)
-        dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-        tcell_context = request.env[TCellAgent::Instrumentation::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_form_parameter(param_name, tcell_context.route_id)
-            if actions
-              actions.each { |action|
-                tcell_context.add_filter_for_request_parameter(param_value, action, param_name)
-              }
+
+      if (::Rails::VERSION::MAJOR == 4)
+        ActionDispatch::Journey::Routes.class_eval do
+          alias_method :tcell_add_route, :add_route
+          def add_route(app, path, conditions, defaults, name = nil)
+            route = tcell_add_route(app, path, conditions, defaults, name)
+
+            TCellAgent::Instrumentation.safe_block("Reporting new route") do
+              TCellAgent::Instrumentation::Rails.instrument_route(route)
             end
-          }
+
+            route
+          end
         end
       end
-      TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request forms)") {
-        _handle_dataexpsure_forms(request)
-      }
-      def self._handle_dataexpsure_headers(request)
-        dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-        tcell_context = request.env[TCellAgent::Instrumentation::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)
-              }
+
+      if (::Rails::VERSION::MAJOR == 5)
+        ActionDispatch::Journey::Routes.class_eval do
+          alias_method :tcell_add_route, :add_route
+          def add_route(name, mapping)
+            route = tcell_add_route(name, mapping)
+
+            TCellAgent::Instrumentation.safe_block("Reporting new route") do
+              TCellAgent::Instrumentation::Rails.instrument_route(route)
             end
-          }
+
+            route
+          end
         end
       end
-      TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request headers)") {
-        _handle_dataexpsure_headers(request)
-      }
-      def self._handler_dataexposure_cookies(request)
-        dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-        tcell_context = request.env[TCellAgent::Instrumentation::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)
-              }
+
+      if (::Rails::VERSION::MAJOR == 5 || (::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR >= 2))
+        ActionDispatch::Journey::Router.class_eval do
+          alias_method :tcell_serve, :serve
+          def serve(req)
+            if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? &&
+                TCellAgent.configuration.should_intercept_requests?
+              TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
+                match, parameters, route = find_routes(req).first
+
+                TCellAgent::Instrumentation::RouteId.update_context(req.env, parameters, route)
+              end
+
+              patches_response = TCellAgent::Instrumentation::Patches.block?(req)
+              if patches_response
+                return [patches_response, {}, []]
+              end
+
+              TCellAgent::DLP.handle_request_dlp_parameters(req)
             end
-          }
+
+            tcell_serve(req)
+          end
+
         end
       end
-      TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request cookies)") {
-        _handler_dataexposure_cookies(request)
-      }
-    end
-  end
 
-  ActiveSupport.on_load(:action_controller) do
-    ActionController::Base.class_eval do
-
-      prepend_around_filter :tell_around_filter_routes
-      def tell_around_filter_routes
-        begin
-
-          if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? && TCellAgent.configuration.should_intercept_requests?
-            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::TCELL_ID]
-                if tcell_context
-                  tcell_context.route_id = TCellAgent::SensorEvents::Util.calculateRouteId(request.method.downcase, route_path)
-                end
+      if (::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR < 2)
+        require 'action_dispatch/journey/router/utils'
+
+        ActionDispatch::Journey::Router.class_eval do
+          alias_method :tcell_call, :call
+          def call(env)
+            env['PATH_INFO'] = ActionDispatch::Journey::Router::Utils.normalize_path(env['PATH_INFO'])
+
+            if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? &&
+                TCellAgent.configuration.should_intercept_requests?
+              TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
+                match, parameters, route = find_routes(env).first
+
+                TCellAgent::Instrumentation::RouteId.update_context(env, parameters, route)
+              end
+
+              tcell_request = Rack::Request.new(env)
+
+              patches_response = TCellAgent::Instrumentation::Patches.block?(tcell_request)
+              if patches_response
+                return [patches_response, {}, []]
               end
-            }
-            TCellAgent::AroundFilters.handle_request_dlp_parameters(request)
+
+              TCellAgent::DLP.handle_request_dlp_parameters(tcell_request)
+            end
+
+            tcell_call(env)
           end
-          yield
         end
       end
+
     end
   end
 end

data/lib/tcell_agent/rails/routes/grape.rb

@@ -0,0 +1,113 @@
+require 'tcell_agent/configuration'
+
+module TCellAgent
+  module Instrumentation
+
+    def self.grape_route?(route)
+      if defined?(Grape::API)
+        begin
+          if ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR < 2
+            # does app inherit from Grape::API?
+            route.app < Grape::API
+          else
+            # does app inherit from Grape::API?
+            route.app.app < Grape::API
+          end
+
+          return true
+        rescue
+        end
+      end
+
+      false
+    end
+
+    def self.instrument_grape_api(grape_mount_endpoint, routes)
+      if routes
+        routes.each do |route|
+          route_info = grape_route_info(route)
+
+          route_path = "#{grape_mount_endpoint}#{route_info[:path]}"
+          route_method = route_info[:method]
+
+          route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, route_path)
+          TCellAgent.send_event(
+            TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
+              route_path, route_method, route_id, nil, nil
+            )
+          )
+        end
+      end
+    end
+
+    def self.grape_route_info(route)
+      major, minor, tiny = Gem.loaded_specs['grape'].version.to_s.split('.')
+      if major.to_i == 0 && minor.to_i < 16
+        {
+          method: route.route_method,
+          path: route.route_path
+        }
+      else
+        {
+          method: route.request_method,
+          path: route.path
+        }
+      end
+    end
+
+    def self.grape_route_params(route)
+      major, minor, tiny = Gem.loaded_specs['grape'].version.to_s.split('.')
+      if major.to_i == 0 && minor.to_i < 16
+        route.route_params
+      else
+        route.params
+      end
+    end
+
+    if defined?(Grape::Endpoint)
+      def self.grape_path_params(env, route)
+        all_params = Grape::Request.new(env).params
+
+        self.grape_route_params(route).keys.inject({})do |memo, key|
+          memo[key] = all_params[key]
+
+          memo
+        end
+      end
+
+      Grape::Endpoint.class_eval do
+
+        alias_method :tcell_call!, :call!
+        def call!(env)
+          if TCellAgent.configuration.enabled &&
+              TCellAgent.configuration.should_instrument? &&
+              TCellAgent.configuration.should_intercept_requests?
+
+            TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
+
+              tcell_context = env[TCellAgent::Instrumentation::TCELL_ID]
+              if tcell_context && tcell_context.grape_mount_endpoint && self.respond_to?(:routes)
+                route = routes.first
+
+                if route
+                  route_info = TCellAgent::Instrumentation.grape_route_info(route)
+                  route_path = "#{tcell_context.grape_mount_endpoint}#{route_info[:path]}"
+
+                  if route_path
+                    tcell_context.path_parameters = TCellAgent::Instrumentation.grape_path_params(env, route)
+                    tcell_context.route_id =
+                      TCellAgent::SensorEvents::Util.calculateRouteId(tcell_context.request_method, route_path)
+                  end
+                end
+              end
+            end
+          end
+
+          tcell_call!(env)
+        end
+      end
+
+    end
+
+  end
+end