tcell_agent 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2e3e8eaef2cd61c9cc3effe2b97fa731eeebecf
-  data.tar.gz: a10e24f2d47029ade958ac9b75ebb7f287abd825
+  metadata.gz: 3e9ec10853e07ac321bca036627e9e98a9e8545f
+  data.tar.gz: b1dce50c2950629b10397802e5a6f16fa1beabc1
 SHA512:
-  metadata.gz: e5f0910986b130a99684b68ed99fe5af1bef89f82a9a555a4dc6f233e4580d7ceeaa2b335fe02e85a79a34407d5f41202c14d5c7f3bb7151215a94e04e22e640
-  data.tar.gz: 79176adc5b5892cafcc7da924d1f0fcbcea066af31f2615c1744117975e8eae0a2a91b56f6a32b6638c778f60e09531e703d43275558c04a8d533327a69b7dca
+  metadata.gz: 1506c43edb7ae723f675b4cb1e8e5d0703505941c00cde7c399d3b7c64810ce3f8f0b53744b9eb61719d79272d8676519b0183c4af124f89702d576793b2f342
+  data.tar.gz: fca2c0f960400a55a7f67c7e0d93465174d785b299f703271cc1ce0befc2430093f0556e570469c0a9251ac6da7aff06dba8180499d284b4a6989d0b11ab7980

data/lib/tcell_agent/agent.rb

@@ -124,11 +124,12 @@ module TCellAgent
         puts " ********* ********* ********* *********"
         return
       end
-      #puts "Starting"
+
+      TCellAgent.logger.debug("Starting thread agent")
+
       self.ensure_policy_polling_running
       self.ensure_event_processor_running
-      #puts "Ending"
     end
 
   end
-end
+end

data/lib/tcell_agent/agent/event_processor.rb

@@ -54,27 +54,14 @@ module TCellAgent
       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
           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
 
-          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
@@ -82,6 +69,7 @@ module TCellAgent
                 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 
@@ -151,6 +139,7 @@ module TCellAgent
                   @dispatchEvents = []
                 }
               end
+
             rescue Exception => e
               last_run_time = Time.now
               TCellAgent.logger.error("Exception while processing events: #{e.message}")
@@ -164,7 +153,9 @@ module TCellAgent
           TCellAgent.logger.error("Exception while starting processor: #{xyz.message}")
           TCellAgent.logger.debug(xyz.backtrace)
         end
+
       end
+
     end
 
     def ensure_fork_event_thread_running
@@ -201,7 +192,7 @@ module TCellAgent
         rescue Exception => e
           TCellAgent.logger.error("Exception while running (forked) events: #{e.message}")
           TCellAgent.logger.debug(e.backtrace)
-        end          
+        end
       end
     end
 
@@ -248,7 +239,7 @@ module TCellAgent
         rescue Exception => e
           TCellAgent.logger.error("Exception while running (forked) metrics: #{e.message}")
           TCellAgent.logger.debug(e.backtrace)
-        end          
+        end
       end
     end
 
@@ -271,14 +262,17 @@ module TCellAgent
           self.queue_forked_event(event)
           return
         end
+
         begin
           self.ensure_event_processor_running
           @event_queue_monitor.synchronize {
-            @eventQueue.push(event)
+            @eventQueue.push(event, 10)
           }
-        rescue RuntimeError => te
+
+        rescue RuntimeError
           TCellAgent.logger.debug("Dropping event because queue full")
         end
+
       rescue Exception => queue_exception
         TCellAgent.logger.debug("Could not add event #{queue_exception.message}")
       end
@@ -305,6 +299,5 @@ module TCellAgent
       end
     end
 
-
   end
-end
+end

data/lib/tcell_agent/agent/fork_pipe_manager.rb

@@ -65,6 +65,7 @@ module TCellAgent
         end
       end
     end
+
     @@event_pipe_manager = ForkPipeManager.new { |event|
       begin
         TCellAgent.send_event(event)
@@ -72,7 +73,7 @@ module TCellAgent
         TCellAgent.logger.error("Could handle send_event_block")
         TCellAgent.logger.error(block_exception.message)
         TCellAgent.logger.debug(block_exception.backtrace)
-      end   
+      end
     }
     @@metrics_pipe_manager = ForkPipeManager.new { |val|
       begin

data/lib/tcell_agent/agent/policy_manager.rb

@@ -43,7 +43,7 @@ module TCellAgent
 
     def start_policy_polling
       if TCellAgent.configuration.fetch_policies_from_tcell == true
-        TCellAgent.logger.debug("starting background polling thread")
+        TCellAgent.logger.debug("Starting policy polling thread")
         @policy_polling_thread = Thread.new do
           last_poll_time = 0
           last_run = Time.now
@@ -147,4 +147,4 @@ module TCellAgent
     end
 
   end
-end
+end

data/lib/tcell_agent/configuration.rb

@@ -29,7 +29,8 @@ module TCellAgent
       :base_dir,
       :cache_filename,
       :js_agent_api_base_url,
-      :js_agent_url
+      :js_agent_url,
+      :raise_exceptions
 
     attr_accessor :exp_config_settings
 
@@ -48,6 +49,8 @@ module TCellAgent
       @event_batch_size_limit = 25
       @event_time_limit_seconds = 55
 
+      @raise_exceptions = false
+
       read_config_using_env
       read_config_from_file(filename)
 
@@ -58,11 +61,11 @@ module TCellAgent
 
       begin
         @host_identifier = (Socket.gethostname() || "localhost")
-      rescue Exception => e 
+      rescue Exception
         @host_identifier = "host_identifier_not_found"
       end
       @uuid = SecureRandom.uuid
-      
+
       FileUtils::mkdir_p File.dirname(@cache_filename)
       if @logging_options and @logging_options["filename"]
         FileUtils::mkdir_p File.dirname(@logging_options["filename"])
@@ -70,6 +73,7 @@ module TCellAgent
         FileUtils::mkdir_p File.dirname(@default_log_filename)
       end
     end
+
     def read_config_using_env
       @app_id = ENV["TCELL_APP_ID"]
       @api_key = ENV["TCELL_API_KEY"]
@@ -77,11 +81,15 @@ module TCellAgent
       @tcell_api_url = ENV["TCELL_API_URL"]
       @tcell_input_url = ENV["TCELL_INPUT_URL"]
       @demomode = ENV["TCELL_DEMOMODE"] || @demomode
+
       if @demomode
         @event_batch_size_limit = 2
         @event_time_limit_seconds = 5
       end
+
+      @raise_exceptions = [true, "true", "yes", "1"].include?(ENV["TCELL_RAISE_EXCEPTIONS"])
     end
+
     def read_config_from_file(filename)
       if File.file?(filename)
         #puts "tCell.io: Loading from file"
@@ -95,7 +103,7 @@ module TCellAgent
             @app_id ||= app_data["app_id"]
             @app_id ||= app_data["name"]
             @api_key ||= app_data["api_key"]
-           
+
             # Optional
             @enabled = app_data.fetch("enabled", true)
             @preload_policy_filename = app_data.fetch("preload_policy_filename", nil)
@@ -157,5 +165,7 @@ module TCellAgent
       end # filename exist
     end #def read
   end # class
+
   TCellAgent.configuration ||= TCellAgent::Configuration.new
-end
+
+end

data/lib/tcell_agent/instrumentation.rb

@@ -35,8 +35,8 @@ module TCellAgent
         @database_filters = Hash.new{|h,k| h[k] = Set.new}
       end
       def add_response_db_filter(term, action_obj, database, schema, table, field)
-        if (term != nil and term != '')
-            self.database_filters[term].add([database, schema, table, field, action_obj])
+        if (term != nil && term != '' && term.to_s.length >= 5)
+          self.database_filters[term.to_s].add([database, schema, table, field, action_obj])
         end
       end
       def filter_body(body)
@@ -164,4 +164,4 @@ module TCellAgent
       end
     end
   end
-end
+end

data/lib/tcell_agent/logger.rb

@@ -4,7 +4,9 @@ require 'logger'
 require 'tcell_agent/configuration'
 
 module TCellAgent
+
   @@logger_pid = Process.pid
+
   def self.loggingLevelFromString(levelString)
     if (levelString == "DEBUG")
       return Logger::DEBUG
@@ -17,14 +19,18 @@ module TCellAgent
     elsif (levelString == "FATAL")
       return Logger::FATAL
     end
+
     return Logger::ERROR
   end
+
   def self.logger
     if defined?(@logger) and @logger_pid == Process.pid
-        return @logger
+      return @logger
     end
+
     @logger_pid = Process.pid
     logging_options = TCellAgent.configuration.logging_options
+
     if logging_options && logging_options["enabled"]
       FileUtils.mkdir_p 'tcell/logs'
       level = loggingLevelFromString(logging_options["level"])
@@ -35,15 +41,19 @@ module TCellAgent
       @logger.formatter = proc do |severity, datetime, progname, msg|
         # ISO 8601 format
         date_format = datetime.strftime("%Y-%m-%d %H:%M:%S,%L%z")
-         "[#{date_format}] #{severity}: #{msg}\n"
+         "[#{date_format}] #{severity}[#{@logger_pid}]: #{msg}\n"
       end
+
       return @logger
     end
+
     logger = Logger.new(TCellAgent.configuration.default_log_filename)
     logger.level = Logger::ERROR
     return logger
   end
+
   def self.logger=(logger)
     @logger = logger
   end
+
 end

data/lib/tcell_agent/rails/routes.rb

@@ -1,126 +1,90 @@
 
 module TCellAgent
   ActiveSupport.on_load(:action_controller) do
-    ActionController::Base.class_eval do      
-          around_filter :tell_around_filter_routes
-          def tell_around_filter_routes 
-            begin 
-              TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") {
-                route = Rails.application.routes.router.recognize(request) { |route, _| route }.first
-                if route
-                  route_path = route[2].path.spec
-                  tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-                  tcell_context.route_id = TCellAgent::SensorEvents::Util.calculateRouteId(request.method.downcase, route_path)
-                end
-              }
-              yield
+
+    ActionController::Base.class_eval do
+
+      around_filter :tell_around_filter_routes
+      def tell_around_filter_routes
+        begin
+          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::Rails::Middleware::TCELL_ID]
+              tcell_context.route_id = TCellAgent::SensorEvents::Util.calculateRouteId(request.method.downcase, route_path)
             end
-          end
+          }
+          yield
+        end
+      end
+
     end
   end
 end
 
 module TCellAgent
+
   module Instrumentation
+
     module Rails
-      def self.route_path_from_route(route)
-        if (::Rails::VERSION::MAJOR == 4)
-          begin
-            route_path = "#{route[2].path.spec}"
-            if (route_path.end_with?("(.:format)"))
-              route_path = route_path.chomp("(.:format)")
-            end
-            return route_path
-          rescue Exception => inner_excetion
-            TCellAgent.logger.debug("Could not figure out path #{inner_excetion.message}")
-          end
-        end
-        nil
-      end
-      def self.route_from_request(rails_request)
-        if (rails_request.env["action_dispatch.request_id"] == nil)
-          return nil
-        end
-        if (::Rails::VERSION::MAJOR == 4)
-          begin
-            recognized = ::Rails.application.routes.router.recognize(rails_request) { |route, _| route }
-            if recognized
-              return recognized.first
-            end
-          rescue Exception => inner_excetion
-            TCellAgent.logger.debug("Could not figure out path #{inner_excetion.message}")
+      METHODS = ['GET','POST','PUT','DELETE','HEAD',
+                 'PATCH','TRACE','CONNECT','OPTIONS']
+
+      def self.instrument_route(route)
+        if (route.constraints.has_key? :request_method)
+          route_path = "#{route.path.spec}"
+          if (route_path.end_with?("(.:format)"))
+            route_path = route_path.chomp("(.:format)")
           end
+
+          route_destination = route.defaults.to_json.to_s
+
+          route_methods = METHODS.select { |x| route.verb.match(x) }
+          route_methods.each { |route_method|
+            route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, route.path.spec)
+            TCellAgent.send_event(
+              TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
+                route_path, route_method, route_id, nil, route_destination
+              )
+            )
+          }
         end
-        nil
       end
-      def self.route_id_from_request(active_request)
-        route = route_from_request(active_request)
-        if route != nil
-          route_path = route_path_from_route(route)
-          if route_path != nil
-            return TCellAgent::SensorEvents::Util.calculateRouteId(active_request.request_method.downcase, route_path)
-          end
+
+      def self.instrument_routes
+        ::Rails.application.routes.routes.each do |route|
+          self.instrument_route(route)
         end
-        nil
-      end
-      def self.get_routes
       end
+
       if (::Rails::VERSION::MAJOR == 3)
         ActionDispatch::Routing::RouteSet.class_eval do
             alias_method :original_add_route, :add_route
             def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
-              methods = ['GET','POST','PUT','DELETE','HEAD',
-                         'PATCH','TRACE','CONNECT','OPTIONS']
               route = original_add_route(app, conditions, requirements, defaults, name, anchor)
-              if (route.constraints.has_key? :request_method)                  
-                  route_path = "#{route.path.spec}"
-                  if (route_path.end_with?("(.:format)"))
-                    route_path = route_path.chomp("(.:format)")
-                  end
-                  route_destination = route.defaults.to_json.to_s
-                  route_params =  route.path.required_names
-                  route_methods = methods.select {|x| route.verb.match(x) }
-                  route_methods.each { |route_method|
-                    route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, route.path.spec)
-                    TCellAgent.send_event(
-                      TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
-                        route_path, route_method, route_id, nil, route_destination
-                      )
-                    )
-                  }
-              end
+
+              TCellAgent::Instrumentation::Rails.instrument_route(route)
+
               route
             end
         end
       end
+
       if (::Rails::VERSION::MAJOR == 4)
         ActionDispatch::Journey::Routes.class_eval do
           alias_method :original_add_route, :add_route
           def add_route(app, path, conditions, defaults, name = nil)
-          methods = ['GET','POST','PUT','DELETE','HEAD',
-                     'PATCH','TRACE','CONNECT','OPTIONS']
-          route = original_add_route(app, path, conditions, defaults, name)
-          if (route.constraints.has_key? :request_method)
-              route_path = "#{route.path.spec}"
-              if (route_path.end_with?("(.:format)"))
-                route_path = route_path.chomp("(.:format)")
-              end
-              route_destination = route.defaults.to_json.to_s
-              route_params =  route.path.required_names
-              route_methods = methods.select {|x| route.verb.match(x) }
-              route_methods.each { |route_method|
-                route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method.downcase, route.path.spec)
-                TCellAgent.send_event(
-                  TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
-                    route_path, route_method, route_id, nil, route_destination
-                  )
-                )
-              }
-            end
+            route = original_add_route(app, path, conditions, defaults, name)
+
+            TCellAgent::Instrumentation::Rails.instrument_route(route)
+
             route
           end
         end
-      end #endif rails version = 4
+      end
+
     end
   end
-end
+end

data/lib/tcell_agent/servers/puma.rb

@@ -0,0 +1,59 @@
+unless Puma.cli_config.options[:preload_app]
+  # this ensures instrumentation runs for preload_app = false.
+  # Instrumentation will run for each worker but there's
+  # nothing we can do about that (Unicorn's preload_app behaves the same way)
+  Puma::Server.class_eval do
+
+    alias_method :original_run, :run
+    def run(background=true)
+      TCellAgent.run_instrumentation("Puma Cluster Mode (Worker)")
+
+      original_run(background)
+    end
+
+  end
+
+
+else
+
+  if Puma.cli_config.options[:workers] == 0
+    # Puma is running in single mode, so run both the initial instrumentation and
+    # start the agent
+    Puma::Runner.class_eval do
+
+      alias_method :original_start_server, :start_server
+      def start_server
+        TCellAgent.run_instrumentation("Puma Single Mode")
+
+        original_start_server
+      end
+
+    end
+
+  else
+
+    # Runs initial instrumentation only once on the master process
+    puma_server_starting = Proc.new { TCellAgent.run_instrumentation("Puma Cluster Mode") }
+    Puma.cli_config.options[:before_fork].push(puma_server_starting)
+
+    # Each puma worker still needs the agent started but no need to run
+    # initial instrumentation again
+    Puma::Server.class_eval do
+
+      alias_method :original_run, :run
+      def run(background=true)
+        begin
+          TCellAgent.logger.debug("Instrumenting: Puma Cluster Mode (Worker)")
+          TCellAgent.thread_agent.start
+        rescue Exception => e
+          TCellAgent.logger.error("Could not start thread agent. #{e.message}")
+        end
+
+        original_run(background)
+      end
+
+    end
+  end
+
+end
+

data/lib/tcell_agent/servers/rails_server.rb

@@ -0,0 +1,20 @@
+# This file gets included when the web server is launched through
+# `bundle exec rails s` command. The appropriate server will be
+# launched through Rack::Server interface
+
+require("tcell_agent/servers/unicorn") if defined?(Unicorn::HttpServer)
+require("tcell_agent/servers/webrick") if defined?(Rack::Handler::WEBrick)
+require("tcell_agent/servers/thin") if defined?(Thin::Server)
+
+if defined?(Puma::Server)
+  Puma::Server.class_eval do
+
+    alias_method :original_run, :run
+    def run(background=true)
+      TCellAgent.run_instrumentation("Puma Single Mode")
+
+      original_run(background)
+    end
+
+  end
+end

data/lib/tcell_agent/servers/thin.rb

@@ -0,0 +1,10 @@
+Thin::Server.class_eval do
+
+  alias_method :original_start, :start
+  def start
+    TCellAgent.run_instrumentation("Thin Server")
+
+    original_start
+  end
+
+end

data/lib/tcell_agent/servers/unicorn.rb

@@ -0,0 +1,27 @@
+# this ensures instrumentation runs for both preload_app = true and preload_app = false
+# when preload_app = false, instrumentation will run for each worker but there's
+# nothing we can do about that (Puma's preload_app behaves the same way)
+TCellAgent.run_instrumentation("Unicorn")
+
+Unicorn::HttpServer.class_eval do
+
+  # this only runs when preload_app=true because when preload_app=false
+  # the gems aren't loaded early enough for tcell to override
+  # the class definitions
+  alias original_init_worker_process init_worker_process
+  def init_worker_process(work)
+    start_process = original_init_worker_process(work)
+
+    begin
+      TCellAgent.thread_agent.policy_polling_worker_mutex = Mutex.new
+      TCellAgent.thread_agent.policy_polling_thread = nil
+      TCellAgent.thread_agent.start
+
+    rescue Exception => e
+      TCellAgent.logger.error("Could not start thread agent. #{e.message}")
+    end
+
+    start_process
+  end
+
+end

data/lib/tcell_agent/servers/webrick.rb

@@ -0,0 +1,13 @@
+Rack::Handler::WEBrick.class_eval do
+
+  class << self
+    alias_method :original_run, :run
+    def run(app, options={})
+      TCellAgent.run_instrumentation("WEBrick")
+
+      original_run(app, options)
+    end
+  end
+
+end
+

data/lib/tcell_agent/start_background_thread.rb

@@ -6,101 +6,89 @@ require 'tcell_agent/configuration'
 require 'thread'
 
 module TCellAgent
-  def self.run_instrumentation
-    TCellAgent.logger.debug("Instrumenting")
+
+  def self.load_route_instrumentation
     if (TCellAgent.configuration.enabled && TCellAgent.configuration.instrument_for_events)
-        require 'tcell_agent/rails' if defined?(Rails)
-        require 'tcell_agent/sinatra' if defined?(Sinatra)
+      require 'tcell_agent/rails' if defined?(Rails)
+      require 'tcell_agent/sinatra' if defined?(Sinatra)
     end
   end
-end
 
-# creates a fork and pipes a string from parent to child
-if File.basename($0) != 'rake'
-  tcell_server = ENV["TCELL_AGENT_SERVER"]
-  if tcell_server == nil
-    if (File.basename($0) == 'rails' && 
-        Rack::Handler.default &&
-       ((defined?(Thin) && (Rack::Handler.default == Rack::Handler::Thin)) ||
-        (defined?(WEBrick) && (Rack::Handler.default == Rack::Handler::WEBrick))))
-      tcell_server = "thin"
-    elsif defined?(Puma) && defined?(Puma.cli_config) && Puma.cli_config.options[:workers] > 1
-      tcell_server = "puma"
-    elsif defined?(Unicorn)
-      tcell_server = "unicorn"
-    elsif defined?(Puma)
-      tcell_server = "thin" 
-    else
-      puts "[tCell.io] **********************************************************************"
-      puts "[tCell.io] Server used to launch rails not recognized."
-      puts "[tCell.io] You can override this with the env variable"
-      puts "[tCell.io]       TCELL_AGENT_SERVER=thin|puma|unicorn"
-      puts "[tCell.io] **********************************************************************"
+  def self.run_instrumentation(server_name)
+    self.load_route_instrumentation
+
+    begin
+      TCellAgent.logger.debug("Instrumenting: #{server_name}")
+      TCellAgent.thread_agent.start
+    rescue Exception => e
+      TCellAgent.logger.error("Could not start thread agent. #{e.message}")
     end
-  end
-  if tcell_server != nil
-    if (tcell_server == "mock")
-    elsif (tcell_server == "thin" || tcell_server == "webrick")
-      TCellAgent.run_instrumentation
-      TCellAgent.logger.debug("Initializing background thread: Thin or webrick")
+
+    Thread.abort_on_exception = TCellAgent.configuration.raise_exceptions
+    Thread.new do
       begin
-          TCellAgent.thread_agent.start
-      rescue Exception => e
-        TCellAgent.logger.error("Could not start worker.", e.message)
+        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
-    elsif (tcell_server == "puma") 
-      TCellAgent.run_instrumentation
-      TCellAgent.logger.debug("Initializing background thread: Puma Preload")
+
       begin
-          TCellAgent.thread_agent.start
-      rescue Exception => e
-        TCellAgent.logger.error("Could not start worker.", e.message)
+        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
-      # preload app
-      puma_worker_start = Proc.new do
+
+      if (TCellAgent.configuration.enabled && TCellAgent.configuration.instrument_for_events)
         begin
-            TCellAgent.thread_agent.start
+          TCellAgent::Instrumentation::Rails.instrument_routes if defined?(Rails)
+
         rescue Exception => e
-          TCellAgent.logger.error("Could not start worker." + e.message)
-        end
-      end
-      Puma.cli_config.options[:before_worker_boot].push(puma_worker_start)
-    elsif (tcell_server == "unicorn")
-      TCellAgent.run_instrumentation
-      TCellAgent.logger.debug("Initializing background thread: Unicorn")
-      begin
-        TCellAgent.thread_agent.start
-      rescue Exception => e
-        TCellAgent.logger.error("Could not start worker.", e.message)
-      end
-      class Unicorn::HttpServer
-        alias _tcell_start spawn_missing_workers
-        def spawn_missing_workers
-          TCellAgent.logger.debug("Stopping (pre-spawn) agent " + Process.pid.to_s)
-          return _tcell_start
-        end
-        alias old_init_worker_process init_worker_process
-        def init_worker_process(work)
-            start_process = old_init_worker_process(work)
-            begin
-                TCellAgent.logger.debug("Starting (post-spawn) agent " + Process.pid.to_s)
-                TCellAgent.thread_agent.policy_polling_worker_mutex = Mutex.new
-                TCellAgent.thread_agent.policy_polling_thread = nil
-                TCellAgent.thread_agent.start
-            rescue Exception => e
-                TCellAgent.logger.error("Could not start worker.")
-            end
-            start_process
+          if TCellAgent.configuration.raise_exceptions
+            raise e
+
+          else
+            TCellAgent.logger.error("Something went wrong instrumenting the routes")
+            TCellAgent.logger.debug(e.inspect)
+            TCellAgent.logger.debug(e.backtrace)
+          end
         end
       end
-    else
-      puts "[tCell.io] **********************************************************************"
-      puts "[tCell.io] Unknown Server for starting rails: #{tcell_server}"
-      puts "[tCell.io] You can override this with the env variable"
-      puts "[tCell.io]       TCELL_AGENT_SERVER=thin|puma|unicorn"
-      puts "[tCell.io] **********************************************************************"    
     end
+
   end
+
 end
 
+tcell_server = ENV["TCELL_AGENT_SERVER"]
+
+if (!(tcell_server && tcell_server == "mock"))
+
+  if (tcell_server && tcell_server == "webrick") || defined?(Rails::Server)
+
+    require("tcell_agent/servers/rails_server")
+
+  elsif (tcell_server && tcell_server == "thin") || defined?(Thin)
 
+    require("tcell_agent/servers/thin")
+
+  elsif (tcell_server && tcell_server == "puma") || defined?(Puma)
+
+    require("tcell_agent/servers/puma")
+
+  elsif (tcell_server && tcell_server == "unicorn") || defined?(Unicorn)
+
+    require("tcell_agent/servers/unicorn")
+
+  else
+    puts "[tCell.io] **********************************************************************"
+    puts "[tCell.io] Server used to launch rails not recognized."
+    puts "[tCell.io] You can override this with the env variable"
+    puts "[tCell.io]       TCELL_AGENT_SERVER=thin|puma|unicorn"
+    puts "[tCell.io] **********************************************************************"
+  end
+end

data/lib/tcell_agent/utils/queue_with_timeout.rb

@@ -5,7 +5,9 @@ require 'thread'
 require 'logger'
 
 module TCellAgent
+
   class BoundedQueue
+
     def initialize(max_size = :infinite)
       @lock  = Mutex.new
       @items = []
@@ -18,6 +20,7 @@ module TCellAgent
       timeout_policy ||= -> do
         raise "Push timed out"
       end
+
       wait_for_condition(
         @space_available,
         ->{!full?},
@@ -35,8 +38,12 @@ module TCellAgent
         @item_available,
         ->{@items.any?},
         timeout,
-        timeout_policy) do 
-        @items.shift 
+        timeout_policy) do
+
+        item = @items.shift
+        @space_available.signal
+
+        item
       end
     end
 
@@ -45,43 +52,56 @@ module TCellAgent
       @max_size <= @items.size
     end
 
+    def size
+      @items.size
+    end
+
     private
 
-    def wait_for_condition(
-        cv, condition_predicate, timeout=:never, timeout_policy=->{nil})
+    def wait_for_condition(cv, condition_predicate, timeout=:never, timeout_policy=->{nil})
+
       deadline = timeout == :never ? :never : Time.now + timeout
+
       @lock.synchronize do
+
         loop do
           cv_timeout = timeout == :never ? nil : deadline - Time.now
+
           if !condition_predicate.call && cv_timeout.to_f >= 0
-            cv.wait(@lock, cv_timeout) 
+            cv.wait(@lock, cv_timeout)
           end
+
           if condition_predicate.call
             return yield
+
           elsif deadline == :never || deadline > Time.now
             next
+
           else
             return timeout_policy.call
           end
         end
+
       end
     end
   end
 
   class QueueWithTimeout
+
     def initialize
       @mutex = Mutex.new
       @queue = []
       @response_time_table = {}
       @recieved = ConditionVariable.new
     end
-   
+
     def <<(x)
       @mutex.synchronize do
         @queue << x
         @recieved.signal
       end
     end
+
     def add_response_time(route_id, response_time)
       @mutex.synchronize do
         if (route_id == nil || route_id == "")
@@ -94,21 +114,25 @@ module TCellAgent
         @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
+
     def length
       return @queue.length
     end
+
     def get_response_time_table
       return @response_time_table
     end
+
     def reset_response_time_table
       @mutex.synchronize do
         @response_time_table = {}
       end
     end
+
     def pop(non_block = false)
       pop_with_timeout(non_block ? 0 : nil)
     end
-   
+
     def pop_with_timeout(timeout = nil)
       @mutex.synchronize do
         if @queue.empty?
@@ -121,4 +145,4 @@ module TCellAgent
       end
     end
   end
-end
+end

data/lib/tcell_agent/version.rb

@@ -1,5 +1,5 @@
 # See the file "LICENSE" for the full license governing this code.
 
 module TCellAgent
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/spec/lib/tcell_agent/instrumentation_spec.rb

@@ -127,6 +127,8 @@ module TCellAgent
             context.add_response_db_filter("tim123123my", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti21312mmy", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti123123mmy", action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(10233234, action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(true, action, "don", "sam", "tim", "fred")
             body = "this is about timmy1 3123123."
             TCellAgent.empty_event_queue
             context.filter_body(body)
@@ -146,6 +148,8 @@ module TCellAgent
             context.add_response_db_filter("tim123123my", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti21312mmy", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti123123mmy", action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(10233234, action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(true, action, "don", "sam", "tim", "fred")
             body = "this is about timmy1 3123123."
             TCellAgent.empty_event_queue
             context.filter_body(body)
@@ -167,6 +171,8 @@ module TCellAgent
             context.add_response_db_filter("tim123123my", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti21312mmy", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti123123mmy", action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(10233234, action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(true, action, "don", "sam", "tim", "fred")
             body = "this is about timmy1 3123123."
             TCellAgent.empty_event_queue
             context.filter_log(body)
@@ -186,6 +192,8 @@ module TCellAgent
             context.add_response_db_filter("tim123123my", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti21312mmy", action, "don", "sam", "tim", "fred")
             context.add_response_db_filter("ti123123mmy", action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(10233234, action, "don", "sam", "tim", "fred")
+            context.add_response_db_filter(true, action, "don", "sam", "tim", "fred")
             body = "this is about timmy1 3123123."
             TCellAgent.empty_event_queue
             context.filter_log(body)
@@ -195,4 +203,4 @@ module TCellAgent
         end
       end
   end
-end
+end

data/spec/lib/tcell_agent/utils/bounded_queue_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe TCellAgent::BoundedQueue do
+
+  describe "#full?" do
+    it "should be true when the queue is full" do
+      queue = TCellAgent::BoundedQueue.new(1)
+      queue.push("one")
+      expect(queue.full?).to eq(true)
+    end
+
+    it "should return false when the queue is not full" do
+      queue = TCellAgent::BoundedQueue.new(1)
+      expect(queue.full?).to eq(false)
+    end
+  end
+
+  describe "#push" do
+    context "pushing to a queue with space available" do
+      it "should push the item" do
+        queue = TCellAgent::BoundedQueue.new(1)
+        queue.push("one")
+
+        expect(queue.size).to eq(1)
+      end
+    end
+
+    context "pushing to a full queue" do
+      it "should not be possible to push anymore items" do
+        queue = TCellAgent::BoundedQueue.new(1)
+        queue.push("one")
+
+        expect(queue.size).to eq(1)
+        expect(queue.full?).to eq(true)
+
+        expect {
+          queue.push("two", 0.1)
+        }.to raise_error(RuntimeError)
+      end
+    end
+
+  end
+
+  describe "#pop" do
+    context "popping from an empty queue" do
+      it "should return nil when there are no items" do
+        queue = TCellAgent::BoundedQueue.new(1)
+        expect(queue.size).to eq(0)
+
+        expect(queue.pop(0.1)).to eq(nil)
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -21,4 +21,4 @@ module TCellAgent
   end
 end
 
-TCellAgent.run_instrumentation
+TCellAgent.load_route_instrumentation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcell_agent
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Garrett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-20 00:00:00.000000000 Z
+date: 2016-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -117,20 +117,24 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - Rakefile
+- bin/tcell_agent
+- lib/tcell_agent.rb
+- lib/tcell_agent/agent.rb
 - lib/tcell_agent/agent/event_processor.rb
 - lib/tcell_agent/agent/fork_pipe_manager.rb
 - lib/tcell_agent/agent/policy_manager.rb
 - lib/tcell_agent/agent/policy_types.rb
 - lib/tcell_agent/agent/route_manager.rb
 - lib/tcell_agent/agent/static_agent.rb
-- lib/tcell_agent/agent.rb
 - lib/tcell_agent/api.rb
+- lib/tcell_agent/appsensor.rb
 - lib/tcell_agent/appsensor/cmdi.rb
 - lib/tcell_agent/appsensor/path_traversal.rb
 - lib/tcell_agent/appsensor/sqli.rb
 - lib/tcell_agent/appsensor/xss.rb
-- lib/tcell_agent/appsensor.rb
 - lib/tcell_agent/authlogic.rb
 - lib/tcell_agent/configuration.rb
 - lib/tcell_agent/devise.rb
@@ -145,6 +149,7 @@ files:
 - lib/tcell_agent/policies/http_tx_policy.rb
 - lib/tcell_agent/policies/login_fraud_policy.rb
 - lib/tcell_agent/policies/secure_headers_policy.rb
+- lib/tcell_agent/rails.rb
 - lib/tcell_agent/rails/auth/authlogic.rb
 - lib/tcell_agent/rails/auth/devise.rb
 - lib/tcell_agent/rails/dlp.rb
@@ -154,7 +159,6 @@ files:
 - lib/tcell_agent/rails/middleware/headers_middleware.rb
 - lib/tcell_agent/rails/routes.rb
 - lib/tcell_agent/rails/settings_reporter.rb
-- lib/tcell_agent/rails.rb
 - lib/tcell_agent/routes/table.rb
 - lib/tcell_agent/sensor_events/app_config.rb
 - lib/tcell_agent/sensor_events/app_sensor.rb
@@ -168,12 +172,16 @@ files:
 - lib/tcell_agent/sensor_events/util/redirect_utils.rb
 - lib/tcell_agent/sensor_events/util/sanitizer_utilities.rb
 - lib/tcell_agent/sensor_events/util/utils.rb
+- lib/tcell_agent/servers/puma.rb
+- lib/tcell_agent/servers/rails_server.rb
+- lib/tcell_agent/servers/thin.rb
+- lib/tcell_agent/servers/unicorn.rb
+- lib/tcell_agent/servers/webrick.rb
 - lib/tcell_agent/sinatra.rb
 - lib/tcell_agent/start_background_thread.rb
 - lib/tcell_agent/userinfo.rb
 - lib/tcell_agent/utils/queue_with_timeout.rb
 - lib/tcell_agent/version.rb
-- lib/tcell_agent.rb
 - spec/controllers/application_controller.rb
 - spec/lib/tcell_agent/api/api_spec.rb
 - spec/lib/tcell_agent/appsensor_spec.rb
@@ -192,13 +200,11 @@ files:
 - spec/lib/tcell_agent/sensor_events/dlp_spec.rb
 - spec/lib/tcell_agent/sensor_events/util/redirect_utils_spec.rb
 - spec/lib/tcell_agent/sensor_events/util/sanitizer_utilities_spec.rb
+- spec/lib/tcell_agent/utils/bounded_queue_spec.rb
 - spec/lib/tcell_agent_spec.rb
 - spec/resources/normal_config.json
 - spec/spec_helper.rb
-- README.md
-- LICENSE
 - tcell_agent.gemspec
-- bin/tcell_agent
 homepage: https://www.tcell.io
 licenses:
 - Copyright (c) 2015 tCell.io (see LICENSE file)
@@ -221,7 +227,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: tCell.io Agent for Rails & Sinatra
@@ -244,6 +250,7 @@ test_files:
 - spec/lib/tcell_agent/sensor_events/dlp_spec.rb
 - spec/lib/tcell_agent/sensor_events/util/redirect_utils_spec.rb
 - spec/lib/tcell_agent/sensor_events/util/sanitizer_utilities_spec.rb
+- spec/lib/tcell_agent/utils/bounded_queue_spec.rb
 - spec/lib/tcell_agent_spec.rb
 - spec/resources/normal_config.json
 - spec/spec_helper.rb