tcell_agent 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89400e737468ee73780a481cccf4e21c684f0749
-  data.tar.gz: 61f6bdb301b0b0586f955183401b7004aaaa5c84
+  metadata.gz: 6a8919fddc03b6bf97fc9a8c6bd48d9703d870b9
+  data.tar.gz: df20c9fadd9142dda76a34e9d37b90a351ef781d
 SHA512:
-  metadata.gz: 22bc24714bf4f233b7b338b9f48e9abad27e78982d6730f75f8774f49bb9a16dbbd54266f21e7762309e878de6f6093845992d1ca3e76f6725d633062b826b03
-  data.tar.gz: 4becf0b297b2dc0bda7199525d0973cc737009b8fac7ebd7e18dd6277e445b6dd11e42f17a0f73ca6de73eed46c074de4fc96267708b50a199beac9e49b07495
+  metadata.gz: 3fe7bbdebfdb3e6c240e365b8b13a1ebc159e07f8481e9431fc7eb8bda7c61b1054e3d84a282b8c36731aec9bd5ebd8d1bbd369e89a52329ba0f46c884f9e340
+  data.tar.gz: b1c209b6a3ad6dc3e2ceaffcd59e56de1c15fecf0d06a11c75250ae955ca38b62ed7655afedb349eb267c3b88451019c2cd029f66cc883f4470725d804ab7659

data/bin/tcell_agent

@@ -4,6 +4,20 @@
 
 require 'fileutils'
 require 'json'
+require 'optparse'
+
+options = {}
+
+
+subtext = <<HELP
+Commonly used command are:
+   setup :     Setup new config file
+    test :     Run diagnostics classes and config
+loglevel :     Set the loglevel of the tcell agent
+
+See 'tcell_agent COMMAND --help' for more information on a specific command.
+
+HELP
 
 def yesno(default=true)
   begin
@@ -24,16 +38,55 @@ end
 CONFIG_DIR = 'config'
 CONFIG_FILE = 'config/tcell_agent.config'
 
-if (ARGV.length == 0)
-  puts "Usage: tcell_agent command [options]"
-  puts "    setup           Setup new config file"
-  puts "     test           Test classes and config"
-  puts "  preload (filename|rm)        Set the preload file, 'rm' removes it"
+global = OptionParser.new do |opts|
+  opts.banner = "Usage: tcell_agent [options] [subcommand [options]]"
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+  opts.separator ""
+  opts.separator subtext
+end
 
-  Kernel.exit(1)
+subcommands = { 
+  'setup' => OptionParser.new do |opts|
+      opts.banner = "Usage: setup"
+  end,
+  'loglevel' => OptionParser.new do |opts|
+      opts.banner = "Usage: loglevel [options] error|warn|info|debug"
+      opts.on("-o", "--off", "turn logging off ") do |v|
+        options[:off] = v
+      end
+  end,
+  'preload' => OptionParser.new do |opts|
+      opts.banner = "Usage: loglevel [options] [preload_filename]"
+      opts.on("-o", "--off", "turn preloading filename off ") do |v|
+        options[:off] = v
+      end
+  end,
+  'demomode' => OptionParser.new do |opts|
+      opts.banner = "Usage: loglevel [options]"
+      opts.on("-o", "--off", "turn preloading filename off ") do |v|
+        options[:off] = v
+      end
+  end,
+  'test' => OptionParser.new do |opts|
+      opts.banner = "Usage: test"
+      #opts.on("-q", "--[no-]quiet", "quietly run ") do |v|
+      #  options[:quiet] = v
+      #end
+   end
+ }
+
+global.order!
+command = ARGV.shift
+if command == nil
+ puts global
+ Kernel.exit(1)
 end
+subcommands[command].order!
+
 
-if (ARGV[0] == 'setup')
+if (command == 'setup')
   if !File.directory?(CONFIG_DIR)
     print "Directory 'config' not found, create? [Y/n]"
     answer = yesno()
@@ -69,49 +122,61 @@ if (ARGV[0] == 'setup')
   File.open(CONFIG_FILE, 'w'){|f| f.puts JSON.pretty_generate(config_hash) }
   puts "done."
 
-elsif (ARGV[0] == 'loglevel')
-  if (ARGV.length != 2)
-    puts "Usage: tcell_agent loglevel ERROR|INFO|DEBUG|OFF"
-    Kernel.exit(1)
-  end
+elsif (command == 'loglevel')
   file = File.read(CONFIG_FILE)
   config_hash = JSON.parse(file)
-  loglevel = ARGV[1].upcase
   logging_options = config_hash["applications"][0].fetch("logging_options",{})
-  if loglevel == "OFF"
+
+  if options[:off] == true
     logging_options["enabled"] = false
-  elsif loglevel == "ERROR" || loglevel == "INFO" || loglevel == "DEBUG"
-    logging_options["enabled"] = true    
-    logging_options["level"] = loglevel
   else
-    puts "Usage: tcell_agent loglevel ERROR|INFO|DEBUG|OFF"
-    Kernel.exit(1)
+    loglevel = ARGV.pop
+    if (loglevel == nil)
+      puts subcommands[command]
+      Kernel.exit(1)
+    end
+    loglevel = loglevel.upcase
+    if ["ERROR","WARN","INFO","DEBUG"].include?(loglevel)
+      logging_options["enabled"] = true    
+      logging_options["level"] = loglevel
+    else
+      puts subcommands[command]
+      Kernel.exit(1)
+    end
   end
   config_hash["applications"][0]["logging_options"] = logging_options
   File.open(CONFIG_FILE, 'w'){|f| f.puts JSON.pretty_generate(config_hash) }
   puts "done."
 
-elsif (ARGV[0] == 'preload')
-  if (ARGV.length != 2)
-    puts "Usage tcell_agent preload <filename>|rm"
-    Kernel.exit(1)
-  end
-  if !File.exists?(CONFIG_FILE)
-    puts "Config file not found, run 'tcell_agent setup' first"
-    Kernel.exit(1)
-  end
+elsif (command == 'preload')
   file = File.read(CONFIG_FILE)
   config_hash = JSON.parse(file)
-  preload_policy_filename = ARGV[1]
-  if preload_policy_filename == "rm"
+
+  if options[:off] == true
     config_hash["applications"][0].delete("preload_policy_filename")
   else
-    config_hash["applications"][0]["preload_policy_filename"] = ARGV[1]
+    preload_policy_filename = ARGV.pop
+    if (preload_policy_filename == nil)
+      puts subcommands[command]
+      Kernel.exit(1)
+    end
+    config_hash["applications"][0]["preload_policy_filename"] = preload_policy_filename
+  end
+  File.open(CONFIG_FILE, 'w'){|f| f.puts JSON.pretty_generate(config_hash) }
+  puts "done."
+
+elsif (command == 'demomode')
+  file = File.read(CONFIG_FILE)
+  config_hash = JSON.parse(file)
+  if options[:off] == true
+    config_hash["applications"][0].delete("demomode")
+  else
+    config_hash["applications"][0]["demomode"] = true
   end
   File.open(CONFIG_FILE, 'w'){|f| f.puts JSON.pretty_generate(config_hash) }
   puts "done."
 
-elsif (ARGV[0] == 'test')
+elsif (command == 'test')
   puts
   printf "%-50s", "Config file exists... "
   if !File.exists?(CONFIG_FILE)

data/lib/tcell_agent.rb

@@ -5,10 +5,10 @@ require 'tcell_agent/configuration'
 
 module TCellAgent
   TCellAgent.logger.debug("Instrumenting")
-  #if (TCellAgent.configuration.enabled && TCellAgent.configuration.instrument_for_events)
+  if (TCellAgent.configuration.enabled && TCellAgent.configuration.instrument_for_events)
       require 'tcell_agent/rails' if defined?(Rails)
       require 'tcell_agent/sinatra' if defined?(Sinatra)
-  #end
+  end
 end
 
 require 'tcell_agent/agent'
@@ -20,7 +20,6 @@ require 'tcell_agent/policies/secure_headers_policy'
 require 'tcell_agent/policies/honeytokens_policy'
 require 'tcell_agent/policies/clickjacking_policy'
 require 'tcell_agent/policies/appsensor_policy'
-require 'tcell_agent/policies/add_script_tag_policy'
 require 'tcell_agent/policies/login_fraud_policy'
 require 'tcell_agent/policies/dataloss_policy'
 
@@ -30,4 +29,5 @@ require 'tcell_agent/appsensor'
 require 'tcell_agent/sensor_events/util/sanitizer_utilities'
 require 'tcell_agent/sensor_events/util/redirect_utils'
 
-require 'tcell_agent/dataloss'
+require 'tcell_agent/instrumentation'
+require 'tcell_agent/start_background_thread'

data/lib/tcell_agent/agent.rb

@@ -12,33 +12,63 @@ 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 'net/http'
 require 'thread'
 require 'logger'
 require 'json'
+require 'monitor'
 
 module TCellAgent
   class Agent
 
     attr_accessor :start_pid
     attr_accessor :eventQueue
+
+    attr_accessor :fork_event_queue
+    attr_accessor :fork_event_thread
+    attr_accessor :fork_event_thread_mutex
+
+    attr_accessor :metrics_event_queue
+    attr_accessor :metrics_event_thread
+    attr_accessor :metrics_event_thread_mutex
+
     attr_accessor :policies
     attr_accessor :eventProcessorThread
-    attr_accessor :route_counter_table
+    attr_accessor :response_time_table
+    attr_accessor :route_table
 
-    def initialize(start_pid)
-      @start_pid = start_pid
-      @lock = Monitor.new
-      @metricsLock = Monitor.new
-      @policies = {}
-      @route_counter_table = {}
+    attr_accessor :event_processor_thread
+    attr_accessor :event_processor
+    attr_accessor :worker_mutex
 
-      @dispatchEventsTimeout = TCellAgent.configuration.event_time_limit_seconds || 30
+    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
+
+
+    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
-      @dispatchEvents = []
+      @worker_mutex = Mutex.new
+      @policy_polling_worker_mutex = Mutex.new
+      @@policy_tapi = TCellApi.new
 
-      @eventQueue = QueueWithTimeout.new
+      # Agent request thread
+      @policies = {}
+      @lock = Monitor.new
+
+      self.initialize_processor_variables
 
       if TCellAgent.configuration.preload_policy_filename != nil
         TCellAgent.logger.info("Preloading a policy file");
@@ -59,6 +89,30 @@ module TCellAgent
       end
     end
 
+    def initialize_processor_variables
+      @metricsLock = Monitor.new
+      @stop_agent = false
+      @route_table = TCellAgent::Routes::RouteTable.new
+
+      @event_queue_monitor = Monitor.new
+      @event_dispatch_monitor = Monitor.new
+      @mutex = Monitor.new
+
+      @response_time_table = {}
+      @dispatchEvents = []
+      @eventQueue = BoundedQueue.new(200)
+
+      @fork_event_queue=Queue.new
+      @fork_event_thread_mutex=Monitor.new 
+
+      @metrics_event_queue=Queue.new
+      @metrics_event_thread_mutex=Monitor.new
+    end
+
+    def is_parent_process?
+      @start_pid == Process.pid
+    end
+
     def start
       if (TCellAgent.configuration.api_key == nil || 
           TCellAgent.configuration.app_id == nil) 
@@ -70,9 +124,10 @@ module TCellAgent
         puts " ********* ********* ********* *********"
         return
       end
-      self.start_event_processor()
-      self.start_policy_polling()
-
+      #puts "Starting"
+      self.ensure_policy_polling_running
+      self.ensure_event_processor_running
+      #puts "Ending"
     end
 
   end

data/lib/tcell_agent/agent/event_processor.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # See the file "LICENSE" for the full license governing this code.
 
 require "tcell_agent/logger"
@@ -12,13 +14,15 @@ require "tcell_agent/policies/http_redirect_policy"
 require "tcell_agent/policies/secure_headers_policy"
 require "tcell_agent/policies/honeytokens_policy"
 require "tcell_agent/policies/appsensor_policy"
-require "tcell_agent/policies/add_script_tag_policy"
 
 require "tcell_agent/sensor_events/server_agent"
 require "tcell_agent/sensor_events/metrics"
 
 require "tcell_agent/utils/queue_with_timeout"
 
+require "tcell_agent/agent/fork_pipe_manager"
+require "tcell_agent/agent/static_agent"
+
 require 'net/http'
 require 'thread'
 require 'logger'
@@ -28,106 +32,279 @@ require 'json'
 module TCellAgent
   class Agent
 
-    def reset_dispatch
-      @dispatchEvents = []
+    def ensure_event_processor_running
+      return if event_processor_running?
+      @worker_mutex.synchronize do
+        return if event_processor_running?
+        if self.is_parent_process? == false
+          self.initialize_processor_variables
+        end
+        start_event_processor
+      end
     end
-    def start_event_processor(send_empties=true)
-      @events_send_empties = send_empties
 
-      @eventProcessorThread = Thread.new do
-        TCellAgent.logger.debug("starting background event listener")
-        tapi = TCellApi.new
-
-        def dispatch(tapi, events)
-          if (@events_send_empties || events.length > 0)
-            metrics_event = TCellAgent::SensorEvents::MetricsEvent.new            
-            metrics_event.set_route_count_table(@eventQueue.get_response_time_table)
-            events.push( metrics_event )
-            @eventQueue.reset_response_time_table
-            return tapi.sendEventSet(events)
-          end
-          return true
-        end
+    def event_processor_running?
+      if TCellAgent::Agent.is_parent_process? == false
+        return true
+      end
+      @event_processor_thread && @event_processor_thread.alive?
+    end
 
+    def start_event_processor(send_empties=true)
+      if TCellAgent::Agent.is_parent_process? == false
+        return
+      end
+      @events_send_empties = send_empties
+      Thread.abort_on_exception = true
+      @event_processor_thread = Thread.new do
         begin
-          event = TCellAgent::SensorEvents::ServerAgentDetailsSensorEvent.new
-          TCellAgent.send_event(event)
-
-          event = TCellAgent::SensorEvents::ServerAgentPackagesSensorEvent.new
-          TCellAgent.send_event(event)
-        rescue Exception => te
-          TCellAgent.logger.error("Exception sending initial events: #{te.message}")
-          TCellAgent.logger.debug(te.backtrace)
-        end
-        timeout_flag = false
-        last_run_time = Time.now
-        #    orig = (Time.now.to_f * 1000).to_i
-        #    response = @app.call(env)
-        #    response_time = (Time.now.to_f * 1000).to_i - orig
+          tapi = TCellApi.new
+          begin
+            event = TCellAgent::SensorEvents::ServerAgentDetailsSensorEvent.new
+            TCellAgent.send_event(event)
+          rescue Exception => te
+            TCellAgent.logger.error("Exception sending server agent details: #{te.message}")
+            TCellAgent.logger.debug(te.backtrace)
+          end
 
-        loop do
           begin
+            event = TCellAgent::SensorEvents::ServerAgentPackagesSensorEvent.new
+            TCellAgent.send_event(event)
+          rescue Exception => te
+            TCellAgent.logger.error("Exception sending server agent packages: #{te.message}")
+            TCellAgent.logger.debug(te.backtrace)
+          end
+          timeout_flag = false
+          last_run_time = Time.now
+          loop do
             begin
-              now = Time.now
-              wait_for = @dispatchEventsTimeout - (now - last_run_time).to_i.abs
-              #puts "---- ---- "
-              #puts wait_for
-
-              event = @eventQueue.pop_with_timeout([wait_for, 0].max)
-              # puts "Hey, found event"
-              # puts event
-              if event["event_type"] == "RequestRouteTimer"
-              #   puts "Request"
-              #   puts event
-                route_id = event.route_id
-              #   puts "Route"
-              #   puts route_id
-                response_time = event.response_time
-              #   puts "ROUTE"
-                #puts response_time
-                @eventQueue.add_response_time(route_id, response_time)
-                #puts @eventQueue.get_response_time_table
-              #   puts "xxxx"
-              end
-              event.post_process
-              if event.send == true
-                @dispatchEvents.push(event)
-              end
-              if (event.flush or @dispatchEvents.length >= @dispatchEventsLimit or wait_for < 0)
-                last_run_time = Time.now
-                if ( dispatch(tapi, @dispatchEvents) )
-                  self.reset_dispatch
-                else
-                  @dispatchEvents = @dispatchEvents.find_all{|item| item.ensure == true }
+              begin
+                now = Time.now
+                wait_for = @dispatchEventsTimeout - (now - last_run_time).to_i.abs
+                event = @eventQueue.pop([wait_for, 1].max)
+                if event == nil
+                    last_run_time = Time.now
+                    # JJJJJJJJ JJJJJJJ JJJJJJJ JJJJJJJJ JJJJJJJJJ 
+                      if (@events_send_empties || @dispatchEvents.length > 0)
+                        if (@response_time_table.size > 0)
+                          metrics_event = TCellAgent::SensorEvents::MetricsEvent.new
+                          metrics_event.set_route_count_table(@response_time_table)
+                          @event_dispatch_monitor.synchronize {
+                            @dispatchEvents.push( metrics_event )
+                          }
+                          @mutex.synchronize do
+                            @response_time_table = {}
+                          end
+                        end
+                        @event_dispatch_monitor.synchronize {
+                          events_to_send = @dispatchEvents
+                          result = tapi.sendEventSet(events_to_send)
+                          if ( result )
+                            @event_dispatch_monitor.synchronize {
+                              @dispatchEvents = []
+                            }
+                          else
+                            @event_dispatch_monitor.synchronize {
+                              @dispatchEvents = @dispatchEvents.find_all{|item| item.ensure == true }
+                            }
+                          end
+                        }
+                      end
+                    # JJJJJJJJ JJJJJJJ JJJJJJJ JJJJJJJJ JJJJJJJJJ  
+                else  
+                  event.post_process
+                  if event.send == true
+                    @event_dispatch_monitor.synchronize {
+                      @dispatchEvents.push(event)
+                    }
+                  end
+                  if (event.flush or @dispatchEvents.length >= @dispatchEventsLimit or wait_for < 0)
+                    last_run_time = Time.now
+                    # JJJJJJJJ JJJJJJJ JJJJJJJ JJJJJJJJ JJJJJJJJJ 
+                      if (@events_send_empties || @dispatchEvents.length > 0)
+                        if (@response_time_table.size > 0)
+                          metrics_event = TCellAgent::SensorEvents::MetricsEvent.new
+                          metrics_event.set_route_count_table(@response_time_table)
+                          @event_dispatch_monitor.synchronize {
+                            @dispatchEvents.push( metrics_event )
+                          }
+                          @mutex.synchronize do
+                            @response_time_table = {}
+                          end
+                        end
+                        @event_dispatch_monitor.synchronize {
+                          events_to_send = @dispatchEvents
+                          result = tapi.sendEventSet(events_to_send)
+                          if ( result )
+                            @dispatchEvents = []
+                          else
+                            @dispatchEvents = @dispatchEvents.find_all{|item| item.ensure == true }
+                          end
+                        }
+                      end
+                    # JJJJJJJJ JJJJJJJ JJJJJJJ JJJJJJJJ JJJJJJJJJ  
+                  end
                 end
+              rescue ThreadError => te
+                last_run_time = Time.now
+                @event_dispatch_monitor.synchronize {
+                  @dispatchEvents = []
+                }
               end
-            rescue ThreadError => te
+            rescue Exception => e
               last_run_time = Time.now
-              if ( dispatch(tapi, @dispatchEvents) )
-                self.reset_dispatch
+              TCellAgent.logger.error("Exception while processing events: #{e.message}")
+              TCellAgent.logger.debug(e.backtrace)
+              @event_dispatch_monitor.synchronize {
+                @dispatchEvents = []
+              }
+            end
+          end
+        rescue Exception => xyz
+          TCellAgent.logger.error("Exception while starting processor: #{xyz.message}")
+          TCellAgent.logger.debug(xyz.backtrace)
+        end
+      end
+    end
+
+    def ensure_fork_event_thread_running
+      return if event_fork_thread_running?
+      @fork_event_thread_mutex.synchronize do
+        return if event_fork_thread_running?
+        start_fork_event_thread
+      end
+    end
+
+    def event_fork_thread_running?
+      if TCellAgent::Agent.is_parent_process?
+        return true
+      end
+      @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
-                @dispatchEvents = @dispatchEvents.find_all{|item| item.ensure == true }
+                TCellAgent::Agent.send_to_event_pipe(event)
               end
+            rescue Exception => e
+              TCellAgent.logger.error("Exception while processing (forked) events: #{e.message}")
+              TCellAgent.logger.debug(e.backtrace)
+            end
+          end
+        rescue Exception => 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 Exception => queue_exception
+        TCellAgent.logger.debug("Could not add (forked) event #{queue_exception.message}")
+      end
+    end
+
+    def ensure_metrics_event_thread_running
+      return if event_metrics_thread_running?
+      @metrics_event_thread_mutex.synchronize do
+        return if event_metrics_thread_running?
+        start_metrics_event_thread
+      end
+    end
+
+    def event_metrics_thread_running?
+      if TCellAgent::Agent.is_parent_process?
+        return true
+      end
+      @start_metrics_event_thread && @start_metrics_event_thread.alive?
+    end
+
+    def start_metrics_event_thread
+      @metrics_event_thread = Thread.new do
+        begin
+          loop do
+            begin
+              event = @metrics_event_queue.pop
+              TCellAgent::Agent.send_to_metrics_pipe(event)
+            rescue Exception => e
+              TCellAgent.logger.error("Exception while processing (forked) metrics: #{e.message}")
+              TCellAgent.logger.debug(e.backtrace)
             end
-            #puts "AFTER "
-            #puts Thread.current
-          rescue Exception => e
-            last_run_time = Time.now
-            TCellAgent.logger.error("Exception while processing events: #{e.message}")
-            TCellAgent.logger.debug(e.backtrace)
-            @dispatchEvents = @dispatchEvents.find_all{|item| item.ensure == true }
           end
+        rescue Exception => e
+          TCellAgent.logger.error("Exception while running (forked) metrics: #{e.message}")
+          TCellAgent.logger.debug(e.backtrace)
+        end          
+      end
+    end
+
+    def _queue_metric(event)
+      begin
+        self.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 Exception => queue_exception
+        TCellAgent.logger.debug("Could not add (forked) metric #{queue_exception.message}")
       end
     end
 
     def queueSensorEvent(event)
-      if @eventProcessorThread != nil
-        if @eventQueue.length < 200
-          @eventQueue << event
+      begin
+        if TCellAgent::Agent.is_parent_process? == false
+          self.queue_forked_event(event)
+          return
+        end
+        begin
+          self.ensure_event_processor_running
+          @event_queue_monitor.synchronize {
+            @eventQueue.push(event)
+          }
+        rescue RuntimeError => te
+          TCellAgent.logger.debug("Dropping event because queue full")
+        end
+      rescue Exception => queue_exception
+        TCellAgent.logger.debug("Could not add event #{queue_exception.message}")
+      end
+    end
+
+    def increment_route(route_id, response_time)
+      begin
+        if TCellAgent::Agent.is_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"]
         end
+      rescue Exception => inc_exception
+        TCellAgent.logger.debug("Could not add incrememnt exception #{inc_exception.message}")
       end
     end
 
+
   end
 end