tcell_agent 1.1.3 → 1.1.4

data/lib/tcell_agent/agent/fork_pipe_manager.rb

@@ -1,7 +1,5 @@
-# encoding: utf-8
-
 require 'thread'
-require "tcell_agent/logger"
+require 'tcell_agent/logger'
 
 module TCellAgent
   class Agent
@@ -11,108 +9,105 @@ module TCellAgent
 
       @@parent_id = Process.pid
       def initialize(&block)
-        begin
-          @readp, @writep = IO.pipe('ASCII-8BIT', 'ASCII-8BIT', :binmode => true)
-          if defined?(::Encoding::ASCII_8BIT)
-            @writep.set_encoding(::Encoding::ASCII_8BIT)
-          end
-          if is_parent?
-            self.start_listener(&block)
-          end
-        rescue StandardError => init_exception
-          TCellAgent.logger.error("Could not start listener for pipe to forks")
-          TCellAgent.logger.error(init_exception.message)
-          TCellAgent.logger.debug(init_exception.backtrace)
+        @readp, @writep = IO.pipe('ASCII-8BIT', 'ASCII-8BIT', :binmode => true)
+        if defined?(::Encoding::ASCII_8BIT)
+          @writep.set_encoding(::Encoding::ASCII_8BIT)
         end
+        start_listener(&block) if parent?
+      rescue StandardError => init_exception
+        TCellAgent.logger.error('Could not start listener for pipe to forks')
+        TCellAgent.logger.error(init_exception.message)
+        TCellAgent.logger.debug(init_exception.backtrace)
       end
-      def is_parent?
+
+      def parent?
         @@parent_id == Process.pid
       end
+
       def start_listener(&block)
-        Thread.new {
+        Thread.new do
           loop do
             begin
               packed_bytes = @readp.read(4)
-              event_length = packed_bytes.unpack("L>").first
+              event_length = packed_bytes.unpack('L>').first
               packed_event = @readp.read(event_length)
-              event = Marshal.load(packed_event)
-              if block
-                block.call(event)
-              end
+              event = Marshal.load(packed_event) # rubocop:disable Security/MarshalLoad
+              yield(event) if block
             rescue StandardError => block_exception
-              TCellAgent.logger.error("Could not decode block")
+              TCellAgent.logger.error('Could not decode block')
               TCellAgent.logger.error(block_exception.message)
               TCellAgent.logger.debug(block_exception.backtrace)
               sleep 0.5
             end
           end
-        }
+        end
       end
+
       def send_to_parent(event)
-        if is_parent?
-          #puts "Sending in pipe the wrong way"
-          return
-        else
-          begin
-            packed_event = Marshal.dump(event)
-            packed_bytes = [packed_event.bytesize].pack("L>")
-            @writep.write(packed_bytes+packed_event)
-          rescue StandardError => block_exception
-            TCellAgent.logger.error("Could not write to pipe")
-            TCellAgent.logger.error(block_exception.message)
-            TCellAgent.logger.debug(block_exception.backtrace)
-          end
+        return if parent?
+
+        begin
+          packed_event = Marshal.dump(event)
+          packed_bytes = [packed_event.bytesize].pack('L>')
+          @writep.write(packed_bytes + packed_event)
+        rescue StandardError => block_exception
+          TCellAgent.logger.error('Could not write to pipe')
+          TCellAgent.logger.error(block_exception.message)
+          TCellAgent.logger.debug(block_exception.backtrace)
         end
       end
     end
 
-    @@event_pipe_manager = ForkPipeManager.new { |event|
+    @@event_pipe_manager = ForkPipeManager.new do |event|
       begin
         TCellAgent.send_event(event)
       rescue StandardError => block_exception
-        TCellAgent.logger.error("Could handle send_event_block")
+        TCellAgent.logger.error('Could handle send_event_block')
         TCellAgent.logger.error(block_exception.message)
         TCellAgent.logger.debug(block_exception.backtrace)
       end
-    }
-    @@metrics_pipe_manager = ForkPipeManager.new { |val|
-      TCellAgent::Instrumentation.safe_block("Handling metrics_pipe_block") do
-        switch_on = val.fetch("_type","")
+    end
+
+    @@metrics_pipe_manager = ForkPipeManager.new do |val|
+      TCellAgent::Instrumentation.safe_block('Handling metrics_pipe_block') do
+        switch_on = val.fetch('_type', '')
         case switch_on
-        when "increment_route"
+        when 'increment_route'
           TCellAgent.increment_route(
-            val.fetch("route_id",nil),
-            val.fetch("response_time",nil)
+            val.fetch('route_id', nil),
+            val.fetch('response_time', nil)
           )
-        when "discover_database_fields"
+        when 'discover_database_fields'
           TCellAgent.discover_database_fields(
-            val.fetch("route_id",nil),
-            val.fetch("database",nil),
-            val.fetch("schema",nil),
-            val.fetch("table",nil),
-            val.fetch("fields",nil)
+            val.fetch('route_id', nil),
+            val.fetch('database', nil),
+            val.fetch('schema', nil),
+            val.fetch('table', nil),
+            val.fetch('fields', nil)
           )
-        when "increment_session_info"
+        when 'increment_session_info'
           TCellAgent.increment_session_info(
-            val.fetch("hmac_session_id", nil),
-            val.fetch("user_id", nil),
-            val.fetch("ip_address", nil),
-            val.fetch("user_agent", nil)
+            val.fetch('hmac_session_id', nil),
+            val.fetch('user_id', nil),
+            val.fetch('ip_address', nil),
+            val.fetch('user_agent', nil)
           )
         else
-          raise StandardError.new("Metrics Pipe Manager received unknown metric: #{val.fetch("_type","")}")
+          raise StandardError, "Metrics Pipe Manager received unknown metric: #{val.fetch('_type', '')}"
         end
       end
-    }
-    def self.is_parent_process?
-      @@event_pipe_manager.is_parent?
     end
+
+    def self.parent_process?
+      @@event_pipe_manager.parent?
+    end
+
     def self.send_to_metrics_pipe(hash_value)
       @@metrics_pipe_manager.send_to_parent(hash_value)
     end
+
     def self.send_to_event_pipe(event)
       @@event_pipe_manager.send_to_parent(event)
     end
-
   end
 end

data/lib/tcell_agent/agent/policy_manager.rb

@@ -1,20 +1,18 @@
-# encoding: utf-8
-
 # See the file "LICENSE" for the full license governing this code.
 
-require "tcell_agent/logger"
-require "tcell_agent/version"
-require "tcell_agent/api"
-require "tcell_agent/configuration"
+require 'tcell_agent/logger'
+require 'tcell_agent/version'
+require 'tcell_agent/api'
+require 'tcell_agent/configuration'
 
-require "tcell_agent/agent/policy_types"
+require 'tcell_agent/agent/policy_types'
 
-require "tcell_agent/policies/http_tx_policy"
-require "tcell_agent/policies/http_redirect_policy"
+require 'tcell_agent/policies/http_tx_policy'
+require 'tcell_agent/policies/http_redirect_policy'
 
-require "tcell_agent/sensor_events/server_agent"
+require 'tcell_agent/sensor_events/server_agent'
 
-require "tcell_agent/utils/queue_with_timeout"
+require 'tcell_agent/utils/queue_with_timeout'
 
 require 'net/http'
 require 'thread'
@@ -22,11 +20,11 @@ require 'logger'
 require 'json'
 
 module TCellAgent
-  class Agent
-
+  class Agent # rubocop:disable Metrics/ClassLength
     def ensure_policy_polling_running
       return if policy_polling_running?
       return if TCellAgent.configuration.should_start_policy_poll? == false
+
       @policy_polling_worker_mutex.synchronize do
         return if policy_polling_running?
         start_policy_polling_loop
@@ -38,46 +36,43 @@ module TCellAgent
     end
 
     def stop_policy_polling
-      TCellAgent.logger.debug("Stopping policy polling thread")
-      if @policy_polling_thread && @policy_polling_thread.alive?
-        @policy_polling_thread.exit
-      end
+      TCellAgent.logger.debug('Stopping policy polling thread')
+      @policy_polling_thread.exit if @policy_polling_thread && @policy_polling_thread.alive?
     end
 
     def start_policy_polling_loop
-      if TCellAgent.configuration.should_start_policy_poll?
-
-        if TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.tcell_api_url)
-          TCellAgent.logger.error("tCell.io tcell_api_url is missing. Disabling policy polling.")
-          return
-        end
-
-        if TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.app_id)
-          TCellAgent.logger.error("tCell.io app_id is missing. Disabling policy polling.")
-          return
-        end
-
-        TCellAgent.logger.debug("Starting policy polling thread")
+      return unless TCellAgent.configuration.should_start_policy_poll?
 
-        @policy_polling_thread = Thread.new do
-          failure_sleep_time = 30
-          last_poll_time = 0
-          last_run = Time.now
+      if TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.tcell_api_url)
+        TCellAgent.logger.error('tCell.io tcell_api_url is missing. Disabling policy polling.')
+        return
+      end
 
-          loop do
-            failure_sleep_time, last_poll_time = policy_polling_iteration(failure_sleep_time, last_poll_time)
+      if TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.app_id)
+        TCellAgent.logger.error('tCell.io app_id is missing. Disabling policy polling.')
+        return
+      end
 
-            unless TCellAgent.configuration.demomode
-              if (Time.now - last_run) < 2
-                random = Random.new
-                sleeptime = sleep(random.rand(5..20))
-                TCellAgent.logger.debug("Rate limiting: sleeping #{sleeptime} seconds")
-                sleep(sleeptime)
-              end
+      TCellAgent.logger.debug('Starting policy polling thread')
 
-              last_run = Time.now
+      @policy_polling_thread = Thread.new do
+        failure_sleep_time = 30
+        last_poll_time = 0
+        last_run = Time.now
+
+        loop do
+          failure_sleep_time, last_poll_time = policy_polling_iteration(failure_sleep_time, last_poll_time)
+
+          unless TCellAgent.configuration.demomode
+            if (Time.now - last_run) < 2
+              random = Random.new
+              sleeptime = sleep(random.rand(5..20))
+              TCellAgent.logger.debug("Rate limiting: sleeping #{sleeptime} seconds")
+              sleep(sleeptime)
             end
           end
+
+          last_run = Time.now
         end
       end
     end
@@ -86,115 +81,105 @@ module TCellAgent
       begin
         policy_jsons = @@policy_tapi.poll_api(last_poll_time)
 
-        if policy_jsons == nil
+        if policy_jsons.nil?
           TCellAgent.logger.error("Policy was nil. Sleeping for #{failure_sleep_time}")
 
           sleep(failure_sleep_time)
 
-          if failure_sleep_time < 480
-            failure_sleep_time *= 2
-          end
+          failure_sleep_time *= 2 if failure_sleep_time < 480
 
           return [failure_sleep_time, last_poll_time]
 
-        elsif policy_jsons.key?("last_id")
-          if policy_jsons["last_id"] != 0
-            last_poll_time = policy_jsons["last_id"]
+        elsif policy_jsons.key?('last_id')
+          if policy_jsons['last_id'] != 0
+            last_poll_time = policy_jsons['last_id']
           end
         end
 
         failure_sleep_time = 30
 
-        processPolicyJson(policy_jsons)
-
+        process_policy_json(policy_jsons)
       rescue TCellAgent::ConfigurationException
         Thread.exit
       rescue StandardError => e
         TCellAgent.logger.error("exception while handling connection: #{e.message}")
         TCellAgent.logger.debug(e.backtrace)
-        TCellAgent.logger.debug("Sleeping 30 seconds because the tCell.io request failed...")
+        TCellAgent.logger.debug('Sleeping 30 seconds because the tCell.io request failed...')
         sleep(failure_sleep_time)
 
-        if failure_sleep_time < 480
-          failure_sleep_time *= 2
-        end
+        failure_sleep_time *= 2 if failure_sleep_time < 480
       end
 
       [failure_sleep_time, last_poll_time]
     end
 
-    def processPolicyJson(policy_jsons, cache_the_policy=true)
+    def process_policy_json(policy_jsons, cache_the_policy = true)
       return if policy_jsons.nil?
 
-      TCellAgent::PolicyTypes::ClassMap.each do | policy_type, policy_class |
-        if (policy_jsons.key?(policy_type))
-          new_policy = policy_class.from_json(policy_jsons[policy_type])
-          if new_policy
-            @lock.synchronize do
-              @policies[policy_type] = new_policy
-            end
-          end
+      TCellAgent::PolicyTypes::CLASS_MAP.each do |policy_type, policy_class|
+        next unless policy_jsons.key?(policy_type)
+        new_policy = policy_class.from_json(policy_jsons[policy_type])
+        next unless new_policy
+        @lock.synchronize do
+          @policies[policy_type] = new_policy
         end
       end
 
-      @policies[TCellAgent::PolicyTypes::Rust].update_policies(policy_jsons)
-
-      if cache_the_policy
-        (TCellAgent::PolicyTypes::ClassMap.keys +
-        [TCellAgent::PolicyTypes::CSP,
-         TCellAgent::PolicyTypes::Clickjacking,
-         TCellAgent::PolicyTypes::SecureHeaders,
-         TCellAgent::PolicyTypes::JSAgentInjection,
-         TCellAgent::PolicyTypes::AppSensor,
-         TCellAgent::PolicyTypes::Patches,
-         TCellAgent::PolicyTypes::CommandInjection,
-         TCellAgent::PolicyTypes::Regex]).each do |policy_type|
-           @lock.synchronize do
-             cache(policy_type, policy_jsons[policy_type]) if policy_jsons[policy_type]
-           end
+      @policies[TCellAgent::PolicyTypes::RUST].update_policies(policy_jsons)
+
+      return unless cache_the_policy
+
+      (TCellAgent::PolicyTypes::CLASS_MAP.keys +
+      [TCellAgent::PolicyTypes::CSP,
+       TCellAgent::PolicyTypes::CLICKJACKING,
+       TCellAgent::PolicyTypes::SECUREHEADERS,
+       TCellAgent::PolicyTypes::JSAGENTINJECTION,
+       TCellAgent::PolicyTypes::APPSENSOR,
+       TCellAgent::PolicyTypes::PATCHES,
+       TCellAgent::PolicyTypes::COMMANDINJECTION,
+       TCellAgent::PolicyTypes::REGEX]).each do |policy_type|
+         @lock.synchronize do
+           cache(policy_type, policy_jsons[policy_type]) if policy_jsons[policy_type]
          end
-      end
+       end
     end
 
     def cache(policy_name, policy)
       cache_filename = TCellAgent.configuration.cache_filename_with_app_id
 
       begin
-
         TCellAgent::Utils::IO.create_directory(
           File.dirname(cache_filename),
           TCellAgent.configuration.agent_home_owner
         )
 
-        f1 = File.open(cache_filename, File::RDWR|File::CREAT)
+        f1 = File.open(cache_filename, File::RDWR | File::CREAT)
 
-        Timeout::timeout(0.100) { f1.flock(File::LOCK_EX) }
+        Timeout.timeout(0.100) { f1.flock(File::LOCK_EX) }
 
         policy_cache = {}
         existing_policy = f1.read
 
         begin
-          if !existing_policy.nil? && existing_policy != ""
+          if !existing_policy.nil? && existing_policy != ''
             policy_jsons = JSON.parse(existing_policy)
             if policy_jsons
-              if policy_jsons.key?("result")
-                policy_cache = policy_jsons["result"]
-              else
-                policy_cache = policy_jsons
-              end
+              policy_cache = if policy_jsons.key?('result')
+                               policy_jsons['result']
+                             else
+                               policy_jsons
+                             end
             end
           end
           policy_cache[policy_name] = policy
           @complete_policy_cache = policy_cache
         rescue StandardError => e
           TCellAgent.logger.warn(e.message)
-          if @complete_policy_cache
-            policy_cache = @complete_policy_cache
-          end
+          policy_cache = @complete_policy_cache if @complete_policy_cache
         end
 
         f1.rewind
-        f1.write( JSON.dump(policy_cache) )
+        f1.write(JSON.dump(policy_cache))
         f1.flush
         f1.truncate(f1.pos)
 
@@ -204,11 +189,9 @@ module TCellAgent
         )
       rescue StandardError => e
         TCellAgent.logger.warn(e.message)
-
       ensure
         f1.close unless f1.nil?
       end
-
     end
 
     def policies_from_cachefile
@@ -218,23 +201,19 @@ module TCellAgent
 
       begin
         f1 = File.open(cache_filename, File::RDONLY)
-        Timeout::timeout(1) { f1.flock( File::LOCK_SH ) }
+        Timeout.timeout(1) { f1.flock(File::LOCK_SH) }
         policy_filedata = f1.read
         f1.close
 
         policy_jsons = JSON.parse(policy_filedata)
-        if policy_jsons.key?("result")
-          return policy_jsons["result"]
-        end
+        return policy_jsons['result'] if policy_jsons.key?('result')
         @complete_policy_cache = policy_jsons
         return policy_jsons
-
       rescue StandardError => e
         TCellAgent.logger.warn(e.message)
       end
 
-      return nil
+      nil
     end
-
   end
 end