tcell_agent 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d0b4e34b740cbb9f4e3a004dc99b77a01b09a53
-  data.tar.gz: d3522bcd25ca86a2d3cd65e238b580d4a253f6e5
+  metadata.gz: 1fee1b53b8297dddbb44b9f4ae21b6371f61b138
+  data.tar.gz: a78a2255a86ff92852a058b58699acd5537c13e1
 SHA512:
-  metadata.gz: 8c539fcef0eb17c3cbf0f39ae61f54e01843ed197dfc1b65fb813d78387cae444a7c285d2b77cab639a4c845b19798419acd7463e662529fd912282abc29638c
-  data.tar.gz: 33c45e6e14e5cda851e4b3853ab5091322b7aa86be6fe4ba5f552701d4bd8d1289ba26cb4903fb871c8f1b0fcdb2bee887f720e67248a17bdae536b3dc916df7
+  metadata.gz: 23478b101ec414872fb96958c4de2208ad099d898513636e50c5ff22b18ff660b4d73068e0ebfc405a9512c56426ef4d189753f03280c6e1d80d541ff0fd1476
+  data.tar.gz: ea0ce97ae0cbf568cace44c6cfed0a39de4954bec81d0e5e2f012c0a7f710de4ddf19226024d36bac23c00bffdba93b9a64a2d54a69ec62355c5c8a8be37b903

data/bin/tcell_agent

@@ -227,9 +227,17 @@ elsif command == 'test'
   end
   puts 'passed'
 
-  printf '%-50s', 'Application has api_key and app_id... '
+  printf '%-50s', 'Application has app_id... '
   tcell_application = config_hash.fetch('applications')[0]
-  if !tcell_application.key?('app_id') || !tcell_application.key?('api_key')
+  if !tcell_application.key?('app_id') && !ENV['TCELL_AGENT_APP_ID']
+    puts 'failed'
+    Kernel.exit(1)
+  end
+  puts 'passed'
+
+  printf '%-50s', 'Application has api_key... '
+  tcell_application = config_hash.fetch('applications')[0]
+  if !tcell_application.key?('api_key') && !ENV['TCELL_AGENT_API_KEY']
     puts 'failed'
     Kernel.exit(1)
   end

data/lib/tcell_agent.rb

@@ -1,8 +1,8 @@
 # See the file "LICENSE" for the full license governing this code.
 
-require "tcell_agent/utils/passwords"
-require "tcell_agent/utils/strings"
-require "tcell_agent/utils/io"
+require 'tcell_agent/utils/passwords'
+require 'tcell_agent/utils/strings'
+require 'tcell_agent/utils/io'
 require 'tcell_agent/logger'
 require 'tcell_agent/configuration'
 

data/lib/tcell_agent/agent.rb

@@ -1,21 +1,21 @@
 # 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/sensor_events/server_agent"
-require "tcell_agent/utils/queue_with_timeout"
+require 'tcell_agent/sensor_events/server_agent'
+require 'tcell_agent/utils/queue_with_timeout'
 
-require "tcell_agent/agent/event_processor"
-require "tcell_agent/agent/policy_manager"
-require "tcell_agent/agent/static_agent"
-require "tcell_agent/agent/policy_types"
-require "tcell_agent/agent/route_manager"
-require "tcell_agent/agent/fork_pipe_manager"
+require 'tcell_agent/agent/event_processor'
+require 'tcell_agent/agent/policy_manager'
+require 'tcell_agent/agent/static_agent'
+require 'tcell_agent/agent/policy_types'
+require 'tcell_agent/agent/route_manager'
+require 'tcell_agent/agent/fork_pipe_manager'
 
-require "tcell_agent/routes/table"
+require 'tcell_agent/routes/table'
 
 require 'net/http'
 require 'thread'
@@ -25,9 +25,8 @@ require 'monitor'
 
 module TCellAgent
   class Agent
-
     attr_accessor :start_pid
-    attr_accessor :eventQueue
+    attr_accessor :event_queue
 
     attr_accessor :fork_event_queue
     attr_accessor :fork_event_thread
@@ -49,53 +48,46 @@ module TCellAgent
     attr_accessor :policy_polling_thread
     attr_accessor :policy_polling_worker_mutex
 
-
     attr_accessor :event_queue_monitor
     attr_accessor :event_dispatch_monitor
 
     attr_accessor :stop_agent
     attr_accessor :complete_policy_cache
 
-
-    def initialize(start_pid=Process.pid)
+    def initialize(start_pid = Process.pid)
       @start_pid = start_pid
-      @dispatchEventsTimeout = TCellAgent.configuration.event_time_limit_seconds || 55
-      @dispatchEventsLimit = TCellAgent.configuration.event_batch_size_limit || 20
+      @dispatch_events_timeout = TCellAgent.configuration.event_time_limit_seconds || 55
+      @dispatch_events_limit = TCellAgent.configuration.event_batch_size_limit || 20
       @worker_mutex = Mutex.new
       @policy_polling_worker_mutex = Mutex.new
       @@policy_tapi = TCellApi.new
 
       # Agent request thread
       @policies = {
-        TCellAgent::PolicyTypes::Rust => TCellAgent::Policies::RustPolicies.new
+        TCellAgent::PolicyTypes::RUST => TCellAgent::Policies::RustPolicies.new
       }
       @lock = Monitor.new
 
-      self.initialize_processor_variables
+      initialize_processor_variables
 
-      if TCellAgent.configuration.preload_policy_filename != nil
-        TCellAgent.logger.info("Preloading a policy file")
+      if TCellAgent.configuration.preload_policy_filename
+        TCellAgent.logger.info('Preloading a policy file')
         begin
           policy_file = File.open(TCellAgent.configuration.preload_policy_filename).read
           policy_jsons = JSON.parse(policy_file)
-          if policy_jsons.key?("result")
-            policy_jsons = policy_jsons["result"]
-          end
-          processPolicyJson(policy_jsons, false)
+          policy_jsons = policy_jsons['result'] if policy_jsons.key?('result')
+          process_policy_json(policy_jsons, false)
         rescue StandardError => e
           TCellAgent.logger.error(e.message)
         end
       end
       cached_policies = policies_from_cachefile
-      if (cached_policies)
-        processPolicyJson(cached_policies, false)
-      end
+      process_policy_json(cached_policies, false) if cached_policies
     end
 
     def initialize_processor_variables
       @complete_policy_cache = {}
 
-      @metricsLock = Monitor.new
       @stop_agent = false
       @route_table = TCellAgent::Routes::RouteTable.new
 
@@ -103,43 +95,41 @@ module TCellAgent
       @event_dispatch_monitor = Monitor.new
       @mutex = Monitor.new
 
-
       @response_time_table = {}
       @sessions_metrics = TCellAgent::SensorEvents::SessionsMetric.new
       @sessions_metrics_mutex = Monitor.new
 
-      @dispatchEvents = []
-      @eventQueue = BoundedQueue.new(200)
+      @dispatch_events = []
+      @event_queue = BoundedQueue.new(200)
 
-      @fork_event_queue=Queue.new
-      @fork_event_thread_mutex=Monitor.new 
+      @fork_event_queue = Queue.new
+      @fork_event_thread_mutex = Monitor.new
 
-      @metrics_event_queue=Queue.new
-      @metrics_event_thread_mutex=Monitor.new
+      @metrics_event_queue = Queue.new
+      @metrics_event_thread_mutex = Monitor.new
     end
 
-    def is_parent_process?
+    def parent_process?
       @start_pid == Process.pid
     end
 
     def start
-      if (TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.api_key) ||
-          TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.app_id))
-        puts " ********* ********* ********* *********"
-        puts "* tCell.io                               *"
-        puts "* Configuration info is missing, you may  *"
-        puts "* need to download config file and place *"
-        puts "* it in the config/ directory            *"
-        puts " ********* ********* ********* *********"
+      if TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.api_key) ||
+         TCellAgent::Utils::Strings.blank?(TCellAgent.configuration.app_id)
+        puts ' ********* ********* ********* *********'
+        puts '* tCell.io                               *'
+        puts '* Configuration info is missing, you may  *'
+        puts '* need to download config file and place *'
+        puts '* it in the config/ directory            *'
+        puts ' ********* ********* ********* *********'
         TCellAgent.configuration.enabled = false
         return
       end
 
-      TCellAgent.logger.debug("Starting thread agent")
+      TCellAgent.logger.debug('Starting thread agent')
 
-      self.ensure_policy_polling_running
-      self.ensure_event_processor_running
+      ensure_policy_polling_running
+      ensure_event_processor_running
     end
-
   end
 end

data/lib/tcell_agent/agent/event_processor.rb

@@ -1,37 +1,33 @@
-# 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/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/metrics"
+require 'tcell_agent/sensor_events/server_agent'
+require 'tcell_agent/sensor_events/metrics'
 
-require "tcell_agent/utils/queue_with_timeout"
+require 'tcell_agent/utils/queue_with_timeout'
 
-require "tcell_agent/agent/fork_pipe_manager"
-require "tcell_agent/agent/static_agent"
+require 'tcell_agent/agent/fork_pipe_manager'
+require 'tcell_agent/agent/static_agent'
 
 require 'net/http'
 require 'thread'
 require 'logger'
 require 'json'
 
-
 module TCellAgent
-  class Agent
-
+  class Agent # rubocop:disable Metrics/ClassLength
     # cmdi events are special because they can be triggered very easily by running any shell command.
     # Startup scripts are likely to run shell commands. It's not a good idea to startup the event
     # processor before worker processses are forked, so the safest thing to do is let a different
     # event start the event processor to avoid deadlocking worker processes.
-    def safe_to_send_cmdi_events?()
+    def safe_to_send_cmdi_events?
       event_processor_running?
     end
 
@@ -40,71 +36,63 @@ module TCellAgent
       return if TCellAgent.configuration.should_start_event_manager? == false
       @worker_mutex.synchronize do
         return if event_processor_running?
-        if self.is_parent_process? == false
-          self.initialize_processor_variables
-        end
+        initialize_processor_variables if parent_process? == false
         start_event_processor
       end
     end
 
     def event_processor_running?
-      if TCellAgent::Agent.is_parent_process? == false
-        return true
-      end
+      return true if TCellAgent::Agent.parent_process? == false
       @event_processor_thread && @event_processor_thread.alive?
     end
 
     def stop_event_processor
-      TCellAgent.logger.debug("Stopping event processor thread")
-      if @event_processor_thread && @event_processor_thread.alive?
-        @event_processor_thread.exit
-      end
+      TCellAgent.logger.debug('Stopping event processor thread')
+      @event_processor_thread.exit if @event_processor_thread && @event_processor_thread.alive?
     end
 
     def send_dispatch_events(tapi)
-        events_to_send = []
-        @event_dispatch_monitor.synchronize {
-          events_to_send = @dispatchEvents
-          @dispatchEvents = []
-        }
-        if (@response_time_table.size > 0)
-          metrics_event = TCellAgent::SensorEvents::MetricsEvent.new
-          metrics_event.set_route_count_table(@response_time_table)
-          events_to_send.push( metrics_event )
-          @mutex.synchronize do
-            @response_time_table = {}
-          end
-        end
-        if @sessions_metrics.has_sessions?
-          sessions_to_send = []
-          @sessions_metrics_mutex.synchronize do
-            sessions_to_send = @sessions_metrics
-            @sessions_metrics = TCellAgent::SensorEvents::SessionsMetric.new
-          end
-          events_to_send.push( sessions_to_send )
+      events_to_send = []
+      @event_dispatch_monitor.synchronize do
+        events_to_send = @dispatch_events
+        @dispatch_events = []
+      end
+
+      unless @response_time_table.empty?
+        metrics_event = TCellAgent::SensorEvents::MetricsEvent.new
+        metrics_event.set_route_count_table(@response_time_table)
+        events_to_send.push(metrics_event)
+        @mutex.synchronize do
+          @response_time_table = {}
         end
-        success = tapi.send_event_set(events_to_send)
-        if ( success == false )
-          ensured_events = events_to_send.find_all{|item| item.ensure == true }
-          @event_dispatch_monitor.synchronize {
-            @dispatchEvents.push(*ensured_events)
-          }
+      end
+
+      if @sessions_metrics.sessions?
+        sessions_to_send = []
+        @sessions_metrics_mutex.synchronize do
+          sessions_to_send = @sessions_metrics
+          @sessions_metrics = TCellAgent::SensorEvents::SessionsMetric.new
         end
-    end
+        events_to_send.push(sessions_to_send)
+      end
+
+      return if tapi.send_event_set(events_to_send)
 
+      ensured_events = events_to_send.find_all { |item| item.ensure == true }
+      @event_dispatch_monitor.synchronize do
+        @dispatch_events.push(*ensured_events)
+      end
+    end
 
-    def start_event_processor(send_empties=true)
+    def start_event_processor(send_empties = true)
       return if TCellAgent.configuration.should_start_event_manager? == false
 
-      if TCellAgent::Agent.is_parent_process? == false
-        return
-      end
+      return if TCellAgent::Agent.parent_process? == false
 
-      TCellAgent.logger.debug("Starting event processor thread")
+      TCellAgent.logger.debug('Starting event processor thread')
       @events_send_empties = send_empties
       Thread.abort_on_exception = true
       @event_processor_thread = Thread.new do
-
         begin
           tapi = TCellApi.new
 
@@ -113,30 +101,32 @@ module TCellAgent
             begin
               begin
                 now = Time.now
-                wait_for = @dispatchEventsTimeout - (now - last_run_time).to_i.abs
-                event = @eventQueue.pop([wait_for, 1].max)
-                if event == nil
-                  if (@events_send_empties || @dispatchEvents.length > 0)
+                wait_for = @dispatch_events_timeout - (now - last_run_time).to_i.abs
+                event = @event_queue.pop([wait_for, 1].max)
+                if event.nil?
+                  if @events_send_empties || !@dispatch_events.empty?
                     last_run_time = Time.now
-                    self.send_dispatch_events(tapi)
+                    send_dispatch_events(tapi)
                   end
                 else
                   event.post_process
                   if event.send == true
-                    @event_dispatch_monitor.synchronize {
-                      @dispatchEvents.push(event)
-                    }
+                    @event_dispatch_monitor.synchronize do
+                      @dispatch_events.push(event)
+                    end
                   end
-                  if (event.flush || @dispatchEvents.length >= @dispatchEventsLimit || wait_for < 0)
+                  if event.flush || @dispatch_events.length >= @dispatch_events_limit || wait_for < 0
                     last_run_time = Time.now
-                    self.send_dispatch_events(tapi)
+                    send_dispatch_events(tapi)
                   end
                 end
-              rescue ThreadError
+              rescue ThreadError => te
+                TCellAgent.logger.error("ThreadError while processing events: #{te.message}")
+                TCellAgent.logger.debug(te.backtrace)
                 last_run_time = Time.now
-                @event_dispatch_monitor.synchronize {
-                  @dispatchEvents = []
-                }
+                @event_dispatch_monitor.synchronize do
+                  @dispatch_events = []
+                end
               end
             rescue TCellAgent::ConfigurationException
               Thread.exit
@@ -144,18 +134,16 @@ module TCellAgent
               last_run_time = Time.now
               TCellAgent.logger.error("Exception while processing events: #{e.message}")
               TCellAgent.logger.debug(e.backtrace)
-              @event_dispatch_monitor.synchronize {
-                @dispatchEvents = []
-              }
+              @event_dispatch_monitor.synchronize do
+                @dispatch_events = []
+              end
             end
           end
         rescue StandardError => xyz
           TCellAgent.logger.error("Exception while starting processor: #{xyz.message}")
           TCellAgent.logger.debug(xyz.backtrace)
         end
-
       end
-
     end
 
     def ensure_fork_event_thread_running
@@ -167,46 +155,38 @@ module TCellAgent
     end
 
     def event_fork_thread_running?
-      if TCellAgent::Agent.is_parent_process?
-        return true
-      end
+      return true if TCellAgent::Agent.parent_process?
       @fork_event_thread && @fork_event_thread.alive?
     end
 
     def start_fork_event_thread
       @fork_event_thread = Thread.new do
-        begin
-          loop do
-            begin
-              event = @fork_event_queue.pop
-              if event.send == false
-                event.post_process
-              else
-                TCellAgent::Agent.send_to_event_pipe(event)
-              end
-            rescue StandardError => e
-              TCellAgent.logger.error("Exception while processing (forked) events: #{e.message}")
-              TCellAgent.logger.debug(e.backtrace)
+        loop do
+          begin
+            event = @fork_event_queue.pop
+            if event.send
+              TCellAgent::Agent.send_to_event_pipe(event)
+            else
+              event.post_process
             end
+          rescue StandardError => e
+            TCellAgent.logger.error("Exception while processing (forked) events: #{e.message}")
+            TCellAgent.logger.debug(e.backtrace)
           end
-        rescue StandardError => e
-          TCellAgent.logger.error("Exception while running (forked) events: #{e.message}")
-          TCellAgent.logger.debug(e.backtrace)
         end
       end
     end
 
     def queue_forked_event(event)
-      begin
-        self.ensure_fork_event_thread_running
-        if (@fork_event_queue.length() > 100)
-          TCellAgent.logger.debug("Dropping (forked) event because queue full")
-          return
-        end
-        @fork_event_queue.push(event)
-      rescue StandardError => queue_exception
-        TCellAgent.logger.debug("Could not add (forked) event #{queue_exception.message}")
+      ensure_fork_event_thread_running
+      if @fork_event_queue.length > 100
+        TCellAgent.logger.debug('Dropping (forked) event because queue full')
+        return
       end
+      @fork_event_queue.push(event)
+    rescue StandardError => queue_exception
+      TCellAgent.logger.debug("Could not add (forked) event #{queue_exception.message}")
+      TCellAgent.logger.debug(queue_exception.backtrace)
     end
 
     def ensure_metrics_event_thread_running
@@ -218,17 +198,13 @@ module TCellAgent
     end
 
     def event_metrics_thread_running?
-      if TCellAgent::Agent.is_parent_process?
-        return true
-      end
+      return true if TCellAgent::Agent.parent_process?
       @metrics_event_thread && @metrics_event_thread.alive?
     end
 
     def stop_metrics_event_thread
-      TCellAgent.logger.debug("Stopping metrics event thread")
-      if @metrics_event_thread && @metrics_event_thread.alive?
-        @metrics_event_thread.exit
-      end
+      TCellAgent.logger.debug('Stopping metrics event thread')
+      @metrics_event_thread.exit if @metrics_event_thread && @metrics_event_thread.alive?
     end
 
     def start_metrics_event_thread
@@ -247,54 +223,50 @@ module TCellAgent
     end
 
     def _queue_metric(event)
-      return if TCellAgent.configuration.should_consume_event? == false
+      return unless TCellAgent.configuration.should_consume_event?
+
       begin
-        self.ensure_metrics_event_thread_running
-        if (@metrics_event_queue.length() > 100)
-          TCellAgent.logger.debug("Dropping (forked) metric because queue full")
+        ensure_metrics_event_thread_running
+        if @metrics_event_queue.length > 100
+          TCellAgent.logger.debug('Dropping (forked) metric because queue full')
           return
         end
         @metrics_event_queue.push(event)
       rescue StandardError => queue_exception
         TCellAgent.logger.debug("Could not add (forked) metric #{queue_exception.message}")
+        TCellAgent.logger.debug(queue_exception.backtrace)
       end
     end
 
-    def queueSensorEvent(event)
-      return if TCellAgent.configuration.should_consume_event? == false
-      begin
-        if TCellAgent::Agent.is_parent_process? == false
-          self.queue_forked_event(event)
-          return
-        end
+    def queue_sensor_event(event)
+      return unless TCellAgent.configuration.should_consume_event?
 
-        begin
-          self.ensure_event_processor_running
-          @event_queue_monitor.synchronize {
-            @eventQueue.push(event, 10)
-          }
+      if TCellAgent::Agent.parent_process? == false
+        queue_forked_event(event)
+        return
+      end
 
-        rescue RuntimeError
-          TCellAgent.logger.debug("Dropping event because queue full")
+      begin
+        ensure_event_processor_running
+        @event_queue_monitor.synchronize do
+          @event_queue.push(event, 10)
         end
-
       rescue StandardError => queue_exception
-        TCellAgent.logger.debug("Could not add event #{queue_exception.message}")
+        TCellAgent.logger.debug("Dropping event because queue full #{queue_exception.message}")
+        TCellAgent.logger.debug(queue_exception.backtrace)
       end
     end
 
     def increment_session_info(hmac_session_id, user_id, ip_address, user_agent)
-
-      TCellAgent::Instrumentation.safe_block("Incrementing session info") do
-
-        if TCellAgent::Agent.is_parent_process? == false
-          TCellAgent.queue_metric({
-            "_type"=>"increment_session_info",
-            "hmac_session_id" => hmac_session_id,
-            "user_id" => user_id,
-            "ip_address" => ip_address,
-            "user_agent" => user_agent
-          })
+      TCellAgent::Instrumentation.safe_block('Incrementing session info') do
+        if TCellAgent::Agent.parent_process? == false
+          TCellAgent.queue_metric(
+            '_type' => 'increment_session_info',
+            'hmac_session_id' => hmac_session_id,
+            'user_id' => user_id,
+            'ip_address' => ip_address,
+            'user_agent' => user_agent
+          )
           return
         end
 
@@ -309,29 +281,24 @@ module TCellAgent
     end
 
     def increment_route(route_id, response_time)
-      TCellAgent::Instrumentation.safe_block("Incrementing route") do
-
-        if TCellAgent::Agent.is_parent_process? == false
-          TCellAgent.queue_metric({
-            "_type"=>"increment_route",
-            "route_id"=>route_id,
-            "response_time"=>response_time
-          })
+      TCellAgent::Instrumentation.safe_block('Incrementing route') do
+        if TCellAgent::Agent.parent_process? == false
+          TCellAgent.queue_metric(
+            '_type' => 'increment_route',
+            'route_id' => route_id,
+            'response_time' => response_time
+          )
           return
         end
         @mutex.synchronize do
-          if (route_id == nil || route_id == "")
-            route_id = "?"
-          end
-          @response_time_table[route_id] = @response_time_table.fetch(route_id,{})
-          @response_time_table[route_id]["c"] = @response_time_table[route_id].fetch("c",0) + 1
-          @response_time_table[route_id]["mx"] = [@response_time_table[route_id].fetch("mx",0), response_time].max
-          @response_time_table[route_id]["mn"] = [@response_time_table[route_id].fetch("mn",response_time), response_time].min
-          @response_time_table[route_id]["t"] = ((@response_time_table[route_id].fetch("t",0)*(@response_time_table[route_id]["c"]-1)) + response_time) / @response_time_table[route_id]["c"]
+          route_id = '?' if route_id.nil? || route_id == ''
+          @response_time_table[route_id] = @response_time_table.fetch(route_id, {})
+          @response_time_table[route_id]['c'] = @response_time_table[route_id].fetch('c', 0) + 1
+          @response_time_table[route_id]['mx'] = [@response_time_table[route_id].fetch('mx', 0), response_time].max
+          @response_time_table[route_id]['mn'] = [@response_time_table[route_id].fetch('mn', response_time), response_time].min
+          @response_time_table[route_id]['t'] = ((@response_time_table[route_id].fetch('t', 0) * (@response_time_table[route_id]['c'] - 1)) + response_time) / @response_time_table[route_id]['c']
         end
-
       end
     end
-
   end
 end