tcell_agent 1.1.3 → 1.1.4

data/lib/tcell_agent/rails/dlp/process_request.rb

@@ -1,25 +1,24 @@
 module TCellAgent
   module DLP
-
     def self.handle_request_dlp_parameters(request)
-      TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request forms)") {
+      TCellAgent::Instrumentation.safe_block('Handling Dataexposure (request forms)') do
         _handle_dataexpsure_forms(request)
-      }
+      end
 
-      TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request headers)") {
+      TCellAgent::Instrumentation.safe_block('Handling Dataexposure (request headers)') do
         _handle_dataexpsure_headers(request)
-      }
+      end
 
-      TCellAgent::Instrumentation.safe_block("Handling Dataexposure (request cookies)") {
+      TCellAgent::Instrumentation.safe_block('Handling Dataexposure (request cookies)') do
         _handler_dataexposure_cookies(request)
-      }
+      end
     end
 
-    def self.loop_params_hash(method, param_hash, prefix, &block)
+    def self.loop_params_hash(method, param_hash, &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 == ""
+          loop_params_hash(method, param_value, &block)
+        elsif !param_value || !param_value.instance_of?(String) || param_value == ''
           next
         else
           block.call(method, param_name, param_value)
@@ -29,59 +28,50 @@ module TCellAgent
 
     def self.for_params(request, &block)
       get_params = request.GET
-      if get_params
-        self.loop_params_hash('get', get_params, nil, &block)
-      end
+      loop_params_hash('get', get_params, &block) if get_params
       post_params = request.POST
-      if post_params
-        self.loop_params_hash('post', post_params, nil, &block)
-      end
+      loop_params_hash('post', post_params, &block) if post_params
     end
 
     def self._handle_dataexpsure_forms(request)
-      dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+      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)
-            }
+      return unless tcell_context && dataex_policy && dataex_policy.actions_for_form_parameter?
+      for_params(request) do |_method, param_name, param_value|
+        actions = dataex_policy.get_actions_for_form_parameter(param_name, tcell_context.route_id)
+        if actions
+          actions.each do |action|
+            tcell_context.add_filter_for_request_parameter(param_value, action, param_name)
           end
-        }
+        end
       end
     end
 
     def self._handle_dataexpsure_headers(request)
-      dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+      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_/, '').tr('_','-')
-          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
-        }
+      return unless tcell_context && dataex_policy && dataex_policy.actions_for_headers?
+      headers = request.env.select { |k, _v| k.start_with? 'HTTP_' }
+      headers.each do |header_name, header_value|
+        header_name = header_name.sub(/^HTTP_/, '').tr('_', '-')
+        actions = dataex_policy.get_actions_for_header(header_name)
+        next unless actions
+        actions.each do |action|
+          tcell_context.add_filter_for_header_value(header_value, action, header_name)
+        end
       end
     end
 
     def self._handler_dataexposure_cookies(request)
-      dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+      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)
-            }
-          end
-        }
+      return unless tcell_context && dataex_policy && dataex_policy.actions_for_cookie?
+      request.cookies.each do |cookie_name, cookie_value|
+        actions = dataex_policy.get_actions_for_cookie(cookie_name)
+        next unless actions
+        actions.each do |action|
+          tcell_context.add_filter_for_cookie_value(cookie_value, action, cookie_name)
+        end
       end
     end
   end

data/lib/tcell_agent/rails/dlp_handler.rb

@@ -5,17 +5,16 @@ module TCellAgent
   module Instrumentation
     module Rails
       module DLPHandler
-
         def self.report_and_redact_now(dlp_handler, tcell_context, rack_body, content_length)
-          TCellAgent::Instrumentation.safe_block("Handling DLP Report and Redact Now") do
+          TCellAgent::Instrumentation.safe_block('Handling DLP Report and Redact Now') do
             if dlp_handler
               new_content_length = 0
               new_body = []
-              rack_body.each { |str|
+              rack_body.each do |str|
                 dlp_handler.call(tcell_context, str)
                 new_body << str
                 new_content_length += str.bytesize
-              }
+              end
               rack_body.close if rack_body.respond_to?(:close)
 
               rack_body = new_body
@@ -27,7 +26,7 @@ module TCellAgent
         end
 
         def self.handle_dlp!(tcell_context, response)
-          TCellAgent::Instrumentation.safe_block("Running DLP Logging Filters") do
+          TCellAgent::Instrumentation.safe_block('Running DLP Logging Filters') do
             tcell_context.filter_body!(response)
           end
 
@@ -38,20 +37,20 @@ module TCellAgent
           dlp_handler = nil
           tcell_context = nil
 
-          TCellAgent::Instrumentation.safe_block("DLP Handler get handler and context") do
+          TCellAgent::Instrumentation.safe_block('DLP Handler get handler and context') do
             if TCellAgent.configuration.enabled &&
-                TCellAgent.configuration.should_instrument? &&
-                TCellAgent.configuration.should_intercept_requests?
+               TCellAgent.configuration.should_instrument? &&
+               TCellAgent.configuration.should_intercept_requests?
 
               # do all this work so that dlp doesn't run at all unless it's on and there
               # are rules to run
               if TCellAgent::Utils::Rails.processable_response?(response_headers)
-                dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+                dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DATALOSS)
                 if dlp_policy && dlp_policy.get_actions_for_session_id
                   tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
                   if tcell_context && tcell_context.session_id
                     dlp_handler = proc { |tc, resp|
-                      self.handle_dlp!(tc, resp)
+                      handle_dlp!(tc, resp)
                     }
                   end
                 end
@@ -61,7 +60,6 @@ module TCellAgent
 
           [dlp_handler, tcell_context]
         end
-
       end
     end
   end

data/lib/tcell_agent/rails/js_agent_insert.rb

@@ -4,20 +4,19 @@ module TCellAgent
   module Instrumentation
     module Rails
       module JSAgent
-
-        HEAD_SEARCH_REGEX=/<head>/
+        HEAD_SEARCH_REGEX = /<head>/
 
         def self.insert_now(js_agent_handler, script_insert, rack_body, content_length)
-          TCellAgent::Instrumentation.safe_block("Handling JSAgent Insert Now") do
+          TCellAgent::Instrumentation.safe_block('Handling JSAgent Insert Now') do
             if js_agent_handler
               new_content_length = 0
               newbody = []
-              rack_body.each { |str|
+              rack_body.each do |str|
                 modified_str = js_agent_handler.call(script_insert, str)
 
                 newbody << modified_str
                 new_content_length += modified_str.bytesize
-              }
+              end
               rack_body.close if rack_body.respond_to?(:close)
 
               rack_body = newbody
@@ -30,7 +29,7 @@ module TCellAgent
 
         def self.handle_js_agent_insert(script_insert, response)
           new_response = response
-          TCellAgent::Instrumentation.safe_block("Handling JSAgent insert") do
+          TCellAgent::Instrumentation.safe_block('Handling JSAgent insert') do
             new_response = response.sub(
               TCellAgent::Instrumentation::Rails::JSAgent::HEAD_SEARCH_REGEX,
               "<head>#{script_insert}"
@@ -44,17 +43,16 @@ module TCellAgent
           js_agent_handler = nil
           script_insert = nil
 
-          TCellAgent::Instrumentation.safe_block("JSAgent get handler and script insert") do
-            if (response_headers.fetch("Content-Type","").start_with?'text/html')
-              rust_policy = TCellAgent.policy(TCellAgent::PolicyTypes::Rust)
+          TCellAgent::Instrumentation.safe_block('JSAgent get handler and script insert') do
+            if (response_headers['Content-Type'] || '').start_with?('text/html')
+              rust_policy = TCellAgent.policy(TCellAgent::PolicyTypes::RUST)
               if rust_policy
-                js_script_tag = rust_policy.get_js_agent_script_tag(
+                script_insert = rust_policy.get_js_agent_script_tag(
                   request.env[TCellAgent::Instrumentation::TCELL_ID]
                 )
-                if js_script_tag
-                  script_insert = js_script_tag
+                if script_insert
                   js_agent_handler = proc { |si, resp|
-                    self.handle_js_agent_insert(si, resp)
+                    handle_js_agent_insert(si, resp)
                   }
                 end
               end
@@ -63,7 +61,6 @@ module TCellAgent
 
           [js_agent_handler, script_insert]
         end
-
       end
     end
   end

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

@@ -20,6 +20,7 @@ module TCellAgent
           def initialize(app)
             @app = app
           end
+
           def call(env)
             orig = (Time.now.to_f * 1000).to_i
 
@@ -27,17 +28,17 @@ module TCellAgent
 
             if TCellAgent.configuration.should_intercept_requests?
               response_time = (Time.now.to_f * 1000).to_i - orig
-              TCellAgent::Instrumentation.safe_block("Handling Route Time") {
+              TCellAgent::Instrumentation.safe_block('Handling Route Time') do
                 route_id = env[TCellAgent::Instrumentation::TCELL_ID].route_id
                 if route_id
                   TCellAgent.increment_route(route_id, response_time)
                 else
-                  TCellAgent.increment_route("", response_time)
+                  TCellAgent.increment_route('', response_time)
                 end
-              }
-              TCellAgent::Instrumentation.safe_block("Handling Sessions Info") {
-                login_fraud_policy = TCellAgent.policy(TCellAgent::PolicyTypes::LoginFraud)
-                if (login_fraud_policy && login_fraud_policy.session_hijacking_metrics)
+              end
+              TCellAgent::Instrumentation.safe_block('Handling Sessions Info') do
+                login_fraud_policy = TCellAgent.policy(TCellAgent::PolicyTypes::LOGINFRAUD)
+                if login_fraud_policy && login_fraud_policy.session_hijacking_metrics
                   hmac_session_id = env[TCellAgent::Instrumentation::TCELL_ID].hmac_session_id
                   user_id = env[TCellAgent::Instrumentation::TCELL_ID].user_id
                   if user_id && hmac_session_id
@@ -49,7 +50,7 @@ module TCellAgent
                     )
                   end
                 end
-              }
+              end
             end
 
             response

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

@@ -19,9 +19,8 @@ module TCellAgent
   module Instrumentation
     module Rails
       module Middleware
-
         class ContextMiddleware
-          THREADS = {}
+          THREADS = {} # rubocop:disable Style/MutableConstant
           def initialize(app)
             @app = app
           end
@@ -29,7 +28,7 @@ module TCellAgent
           def call(env)
             if TCellAgent.configuration.should_intercept_requests?
               env[TCellAgent::Instrumentation::TCELL_ID] = TCellAgent::Instrumentation::TCellData.new
-              TCellAgent::Instrumentation.safe_block("Setting transaction_id") {
+              TCellAgent::Instrumentation.safe_block('Setting transaction_id') do
                 env[TCellAgent::Instrumentation::TCELL_ID].transaction_id = SecureRandom.uuid
                 request = Rack::Request.new(env)
                 env[TCellAgent::Instrumentation::TCELL_ID].uri = request.url
@@ -41,8 +40,8 @@ module TCellAgent
                 if request.request_method
                   env[TCellAgent::Instrumentation::TCELL_ID].request_method = request.request_method
                 end
-              }
-              env["filter_body_set"] = Set.new
+              end
+              env['filter_body_set'] = Set.new
               ContextMiddleware::THREADS[Thread.current.object_id] = env
             end
 

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

@@ -17,9 +17,7 @@ module TCellAgent
   module Instrumentation
     module Rails
       module Middleware
-
         class GlobalMiddleware
-
           def initialize(app)
             @app = app
           end
@@ -27,16 +25,16 @@ module TCellAgent
           def call(env)
             if TCellAgent.configuration.should_intercept_requests?
               request = Rack::Request.new(env)
-              TCellAgent::Instrumentation.safe_block("Setting session_id & user_id") {
+              TCellAgent::Instrumentation.safe_block('Setting session_id & user_id') do
                 if request.session
                   env[TCellAgent::Instrumentation::TCELL_ID].session_id =
-                    request.session["session_id"]
+                    request.session['session_id']
                   env[TCellAgent::Instrumentation::TCELL_ID].user_id =
-                    TCellAgent::UserInformation.getUserFromRequest(request)
+                    TCellAgent::UserInformation.get_user_from_request(request)
                 end
-              }
+              end
 
-              TCellAgent::Instrumentation.safe_block("Setting hmac_session_id") do
+              TCellAgent::Instrumentation.safe_block('Setting hmac_session_id') do
                 if request.env[TCellAgent::Instrumentation::TCELL_ID].session_id
                   env[TCellAgent::Instrumentation::TCELL_ID].hmac_session_id =
                     TCellAgent::SensorEvents::Util.hmac(request.env[TCellAgent::Instrumentation::TCELL_ID].session_id)
@@ -48,7 +46,6 @@ module TCellAgent
 
             response
           end
-
         end
       end
     end

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

@@ -21,7 +21,6 @@ module TCellAgent
   module Instrumentation
     module Rails
       module Middleware
-
         class HeadersMiddleware
           def initialize(app)
             @app = app
@@ -33,15 +32,15 @@ module TCellAgent
             response = @app.call(env)
 
             if TCellAgent.configuration.should_intercept_requests?
-              TCellAgent::Instrumentation.safe_block("Handling Request") {
+              TCellAgent::Instrumentation.safe_block('Handling Request') do
                 tcell_response = response
                 unless request.env[TCellAgent::Instrumentation::TCELL_ID].patches_blocking_triggered
-                  tcell_response = self._handle_appsensor_js_agent_and_dlp(request, tcell_response)
+                  tcell_response = _handle_appsensor_js_agent_and_dlp(request, tcell_response)
                 end
-                tcell_response = self._handle_redirect(request, tcell_response)
-                tcell_response = self._set_headers(request, tcell_response)
+                tcell_response = _handle_redirect(request, tcell_response)
+                tcell_response = _set_headers(request, tcell_response)
                 response = tcell_response
-              }
+              end
             end
 
             response
@@ -50,7 +49,7 @@ module TCellAgent
           def _set_headers(request, response)
             status, headers, active_response = response
 
-            rust_policies = TCellAgent.policy(TCellAgent::PolicyTypes::Rust)
+            rust_policies = TCellAgent.policy(TCellAgent::PolicyTypes::RUST)
             if rust_policies
               policy_headers = rust_policies.get_headers(
                 request.env[TCellAgent::Instrumentation::TCELL_ID]
@@ -59,11 +58,11 @@ module TCellAgent
                 header_name = header_info['name']
                 header_value = header_info['value']
                 existing_header_value = headers[header_name]
-                if existing_header_value
-                  headers[header_name] = "#{existing_header_value}, #{header_value}"
-                else
-                  headers[header_name] = header_value
-                end
+                headers[header_name] = if existing_header_value
+                                         "#{existing_header_value}, #{header_value}"
+                                       else
+                                         header_value
+                                       end
               end
               response = [status, headers, active_response]
             end
@@ -72,34 +71,33 @@ module TCellAgent
           end
 
           def _handle_redirect(request, response)
-            TCellAgent::Instrumentation.safe_block("Handling Redirect Headers") {
+            TCellAgent::Instrumentation.safe_block('Handling Redirect Headers') do
               status, headers, active_response = response
-              http_redirect_policy = TCellAgent.policy(TCellAgent::PolicyTypes::HttpRedirect)
-              if http_redirect_policy && headers.has_key?("Location")
+              http_redirect_policy = TCellAgent.policy(TCellAgent::PolicyTypes::HTTPREDIRECT)
+              if http_redirect_policy && headers.key?('Location')
                 tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
                 route_id = tcell_context.route_id
                 hmac_session_id = tcell_context.hmac_session_id
                 new_location = http_redirect_policy.enforce(
-                  headers["Location"],
+                  headers['Location'],
                   tcell_context.uri,
                   tcell_context.fullpath,
                   tcell_context.request_method,
                   route_id,
                   status,
                   tcell_context.ip_address,
-                  hmac_session_id)
+                  hmac_session_id
+                )
                 # Enforcement
-                if (new_location)
-                  headers["Location"] = new_location
-                end
+                headers['Location'] = new_location if new_location
               end
               response = [status, headers, active_response]
-            }
+            end
             response
           end
 
           def _handle_appsensor_js_agent_and_dlp(request, response)
-            TCellAgent::Instrumentation.safe_block("Handling AppSensor, JS Agent, and DLP") do
+            TCellAgent::Instrumentation.safe_block('Handling AppSensor, JS Agent, and DLP') do
               status_code, response_headers, response_body = response
 
               js_agent_handler, script_insert =
@@ -131,7 +129,6 @@ module TCellAgent
                                                                                        response_body,
                                                                                        content_length)
 
-
                 response_headers['Content-Length'] = content_length.to_s
 
               elsif response_body.is_a?(Rack::BodyProxy)
@@ -141,17 +138,18 @@ module TCellAgent
                   js_agent_handler,
                   script_insert,
                   dlp_handler,
-                  tcell_context)
+                  tcell_context
+                )
                 defer_appfw_due_to_streaming = true
               end
 
-              rust_policies = TCellAgent.policy(TCellAgent::PolicyTypes::Rust)
+              rust_policies = TCellAgent.policy(TCellAgent::PolicyTypes::RUST)
               if rust_policies && rust_policies.appfirewall_enabled
                 event = TCellAgent::SensorEvents::AppSensorMetaEvent.build(
                   request, content_length, status_code, response_headers
                 )
                 if defer_appfw_due_to_streaming
-                  response_body.appsensor_meta = event
+                  response_body.appsensor_meta_event = event
                 else
                   TCellAgent.send_event(event)
                 end
@@ -162,7 +160,6 @@ module TCellAgent
 
             response
           end
-
         end
       end
     end