tcell_agent 0.2.23 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7c1c47e22a203a4c466d43a4b91f1bf23c08d73
-  data.tar.gz: c8fd4777d74973ed594c6db41d64a5f20909dd62
+  metadata.gz: 13c88a7582aa8c65921222ed524e8000e8d8872a
+  data.tar.gz: 2bf2b713872f81e2950994f56f8d431698410224
 SHA512:
-  metadata.gz: 19291ca9491e12d54e0899ce3f76448bb484d78aeea332defded1132d9c1fc67c739d06d9ff3f7ef567cb767b67f7278f4aa56242cbe52c027778b99ff858ac8
-  data.tar.gz: ab5437c6dfdcb8d1b92327a05632f9d7b7e901e945fee90e4ea6e55a96f8217987da1ee7e1ef128eb49921c61e82434e8d2ab576148fe1cd0c7a655996890663
+  metadata.gz: 40078c7ef5481e0364eff69549a8a3d3fc4197ad7ebb903958443e1f7eaaf8c7310d77cb1ba9d752a2b34a4a2bec748755311e8c58ff10b5570c9c8b02c58e07
+  data.tar.gz: 4469f30d67cce86ae944efd69dabd92f681cbe9d7cbe1878a1f5155d3f464d1962871c5229570c764c5ef416eb9601f0db11dce3809ac73ba96add1e3e21b57f

data/lib/tcell_agent/agent/event_processor.rb

@@ -97,6 +97,7 @@ module TCellAgent
         return
       end
 
+      TCellAgent.logger.debug("Starting event processor thread")
       @events_send_empties = send_empties
       Thread.abort_on_exception = true
       @event_processor_thread = Thread.new do
@@ -134,6 +135,8 @@ module TCellAgent
                   @dispatchEvents = []
                 }
               end
+            rescue TCellAgent::ConfigurationException
+              Thread.exit
             rescue Exception => e
               last_run_time = Time.now
               TCellAgent.logger.error("Exception while processing events: #{e.message}")
@@ -246,7 +249,7 @@ module TCellAgent
     end
 
     def _queue_metric(event)
-      return if TCellAgent.configuration.should_consume_event? == false      
+      return if TCellAgent.configuration.should_consume_event? == false
       begin
         self.ensure_metrics_event_thread_running
         if (@metrics_event_queue.length() > 100)

data/lib/tcell_agent/api.rb

@@ -42,14 +42,8 @@ module TCellAgent
 
     def sendEventSet(events)
       if !TCellAgent.configuration || !TCellAgent.configuration.tcell_input_url || !TCellAgent.configuration.app_id
-        raise "Config Information Not Found, can't send events"
+        raise TCellAgent::ConfigurationException.new("Config Information Not Found, can't send events")
       end
-      current_time = DateTime.now.to_time.to_i
-      #if (events)
-      #  events.each { |event| event.calculateOffset(current_time) }
-      #else
-      #  events = []
-      #end
       if (events == nil)
         return false
       end

data/lib/tcell_agent/appsensor/meta_data.rb

@@ -47,8 +47,8 @@ module TCellAgent
         @flattened_cookie_dict
       end
 
-      def set_body_dict(request_content_len, request_content_type, request_body)
-        if request_content_len > 2000000
+      def set_body_dict(request_content_bytes_len, request_content_type, request_body)
+        if request_content_bytes_len > 2000000
           @body_dict = {}
 
         else

data/lib/tcell_agent/configuration.rb

@@ -6,6 +6,9 @@ require 'socket'
 require 'securerandom'
 
 module TCellAgent
+  class ConfigurationException < StandardError
+  end
+
   class << self
     attr_accessor :configuration
   end
@@ -43,7 +46,8 @@ module TCellAgent
       :agent_home_owner,
       :reverse_proxy,
       :reverse_proxy_ip_address_header,
-      :log_file_name
+      :log_file_name,
+      :log_tag
 
     attr_accessor :disable_all,
       :enabled,
@@ -80,6 +84,7 @@ module TCellAgent
       # a chance to run
       @cache_filename = nil
       @agent_log_dir = nil
+      @log_tag = nil
 
       @logger = nil
       @appfirewall_payloads_logger = nil

data/lib/tcell_agent/logger.rb

@@ -6,6 +6,37 @@ require 'tcell_agent/utils/io'
 
 module TCellAgent
 
+  class TaggedLogger
+    def initialize(tag, logger)
+      @tag = tag
+      @logger = logger
+    end
+
+    def debug(msg)
+      @logger.tagged(@tag) { @logger.debug(msg) }
+    end
+
+    def info(msg)
+      @logger.tagged(@tag) { @logger.info(msg) }
+    end
+
+    def warn(msg)
+      @logger.tagged(@tag) { @logger.warn(msg) }
+    end
+
+    def error(msg)
+      @logger.tagged(@tag) { @logger.error(msg) }
+    end
+
+    def fatal(msg)
+      @logger.tagged(@tag) { @logger.fatal(msg) }
+    end
+
+    def unknown(msg)
+      @logger.tagged(@tag) { @logger.unknown(msg) }
+    end
+  end
+
   class NullLoger < Logger
    def initialize(*args)
    end
@@ -92,7 +123,12 @@ module TCellAgent
 
     if TCellAgent.configuration.logger
       @logger_pid = Process.pid
-      @logger = TCellAgent.configuration.logger
+      if TCellAgent.configuration.log_tag
+        @logger = TCellAgent::TaggedLogger.new(TCellAgent.configuration.log_tag, TCellAgent.configuration.logger)
+      else
+        @logger = TCellAgent.configuration.logger
+      end
+
       return @logger
     end
 

data/lib/tcell_agent/patches/meta_data.rb

@@ -29,9 +29,14 @@ module TCellAgent
           meta_event.session_id = request.env[TCellAgent::Instrumentation::TCELL_ID].hmac_session_id
           meta_event.user_id = request.env[TCellAgent::Instrumentation::TCELL_ID].user_id
 
-          meta_event.request_content_len = (request.content_length || "0").to_i
+          # Positions strio to the beginning of input, resetting lineno to zero.
+          # rails 4.1 seems to read the stringIO directly and so body.gets is empty
+          # this is called
+          request.body.rewind
+
+          meta_event.request_content_bytes_len = (request.content_length || 0).to_i
           meta_event.set_body_dict(
-            meta_event.request_content_len,
+            meta_event.request_content_bytes_len,
             request.content_type,
             request.body.gets
           )
@@ -41,12 +46,12 @@ module TCellAgent
       end
 
       attr_accessor :remote_address, :method, :location, :route_id, :session_id, :user_id, :transaction_id,
-        :request_content_len, :user_agent
+        :request_content_bytes_len, :user_agent
 
       def initialize
         super
 
-        @request_content_len = 0
+        @request_content_bytes_len = 0
         @user_agent = nil
       end
     end

data/lib/tcell_agent/policies/appsensor/request_size_sensor.rb

@@ -15,6 +15,10 @@ module TCellAgent
           policy_json
       )
       end
+
+      def get_content_length(appsensor_meta)
+        appsensor_meta.request_content_bytes_len
+      end
     end
 
   end

data/lib/tcell_agent/policies/appsensor/response_size_sensor.rb

@@ -15,6 +15,10 @@ module TCellAgent
           policy_json
         )
       end
+
+      def get_content_length(appsensor_meta)
+        appsensor_meta.response_content_bytes_len
+      end
     end
 
   end

data/lib/tcell_agent/policies/appsensor/size_sensor.rb

@@ -23,14 +23,21 @@ module TCellAgent
         end
       end
 
-      def check(appsensor_meta, content_length)
+      def get_content_length(appsensor_meta)
+        throw Exception("Not Implemented")
+      end
+
+      def check(appsensor_meta)
         if !@enabled || @excluded_route_ids.fetch(appsensor_meta.route_id, false)
           return
         end
 
-        if content_length && content_length > @limit
+        content_length_bytes = get_content_length(appsensor_meta)
+        content_length_KiB = convert_to_kibibytes(content_length_bytes)
+
+        if content_length_KiB > @limit
           param = payload = pattern = nil
-          meta = { "sz" => content_length }
+          meta = { "sz" => content_length_bytes }
           TCellAgent::AppSensor::Sensor.send_event(
             appsensor_meta,
             @dp_code,
@@ -41,6 +48,14 @@ module TCellAgent
         end
       end
 
+      def convert_to_kibibytes(content_length)
+        if content_length
+          content_length / 1024.0
+        else
+          0
+        end
+      end
+
       def to_s
         "<#{self.class.name} enabled: #{@enabled} limit: #{@limit} dp_code: #{@dp_code} " +
         "excluded_route_ids: #{@excluded_route_ids}>"

data/lib/tcell_agent/policies/appsensor_policy.rb

@@ -93,7 +93,7 @@ module TCellAgent
       def check_request_size(appsensor_meta)
         TCellAgent::Instrumentation.safe_block("AppSensor Testing Response Size") do
           if self.options.has_key?("req_size")
-            self.options["req_size"].check(appsensor_meta, appsensor_meta.request_content_len)
+            self.options["req_size"].check(appsensor_meta)
           end
         end
       end
@@ -101,7 +101,7 @@ module TCellAgent
       def check_response_size(appsensor_meta)
         TCellAgent::Instrumentation.safe_block("AppSensor Testing Response Size") do
           if self.options.has_key?("resp_size")
-            self.options["resp_size"].check(appsensor_meta, appsensor_meta.response_content_len)
+            self.options["resp_size"].check(appsensor_meta)
           end
         end
       end

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

@@ -21,6 +21,8 @@ module TCellAgent
 
         class HeadersMiddleware
 
+          STATUSES_MISSING_CONTENT_LENGTH = Set.new((100..199).to_a + [204, 205, 304])
+
           def initialize(app)
             @app = app
           end
@@ -139,17 +141,36 @@ module TCellAgent
             TCellAgent::Instrumentation.safe_block("Handling AppSensor") {
               status_code, response_headers, response_body = response
 
-              if (!(response_body.is_a?(Array)) && !(response_body.is_a?(Rack::BodyProxy)))
-                return response
+              content_length = 0
+              if response_headers['Content-Length']
+                content_length = response_headers['Content-Length'].to_i
+
+              elsif STATUSES_MISSING_CONTENT_LENGTH.include?(status_code.to_i) ||
+                  TCellAgent::Utils::Strings.present?(response_headers['Transfer-Encoding'])
+                content_length = 0
+
+              elsif response_body.respond_to?(:to_ary) || response_body.is_a?(Rack::BodyProxy)
+                old_body = response_body
+                response_body, content_length = [], 0
+                old_body.each { |str|
+                  response_body << str
+                  content_length += str.bytesize
+                }
+
+                if old_body.is_a?(Rack::BodyProxy)
+                  response_body = Rack::BodyProxy.new(response_body) do
+                    old_body.close if old_body.respond_to?(:close)
+                  end
+                end
               end
 
-              rack_response = Rack::Response.new(response)
-
               event = TCellAgent::SensorEvents::AppSensorMetaEvent.build(
-                request, rack_response, status_code, response_headers
+                request, content_length, status_code, response_headers
               )
               TCellAgent.send_event(event)
+              return [status_code, response_headers, response_body]
             }
+
             response
           end
 

data/lib/tcell_agent/sensor_events/appsensor_event.rb

@@ -19,9 +19,9 @@ module TCellAgent
                      pattern=nil)
         super("as")
         self["dp"] = detection_point
-        self["param"] = param
-        self["remote_addr"] = remote_addr
-        self["m"] = method
+        self["param"] = param if param
+        self["remote_addr"] = remote_addr if remote_addr
+        self["m"] = method if method
         @raw_location = location
         @user_id = user_id
         @hmac_session_id = hmac_session_id

data/lib/tcell_agent/sensor_events/appsensor_meta_event.rb

@@ -20,7 +20,7 @@ module TCellAgent
     class AppSensorMetaEvent < TCellAgent::AppSensor::MetaData
 
       class << self
-        def build(request, rack_response, response_code, response_headers)
+        def build(request, response_content_length, response_code, response_headers)
           meta_event = AppSensorMetaEvent.new
 
           meta_event.remote_address = TCellAgent::Utils::Rails.better_ip(request)
@@ -28,8 +28,9 @@ module TCellAgent
           meta_event.location = "#{request.base_url}#{request.fullpath}"
           meta_event.request_headers = request.env
           meta_event.user_agent = request.env['HTTP_USER_AGENT']
-          meta_event.request_content_len = (request.content_length || "0").to_i
-          meta_event.response_content_len = (rack_response.length || "0").to_i
+          meta_event.request_content_bytes_len = (request.content_length || 0).to_i
+          meta_event.response_content_bytes_len = response_content_length
+
           meta_event.get_dict = request.GET
           meta_event.cookie_dict = request.cookies
 
@@ -45,8 +46,13 @@ module TCellAgent
           meta_event.session_id = request.env[TCellAgent::Instrumentation::TCELL_ID].hmac_session_id
           meta_event.user_id = request.env[TCellAgent::Instrumentation::TCELL_ID].user_id
 
+          # Positions strio to the beginning of input, resetting lineno to zero.
+          # rails 4.1 seems to read the stringIO directly and so body.gets is empty
+          # this is called
+          request.body.rewind
+
           meta_event.set_body_dict(
-            meta_event.request_content_len,
+            meta_event.request_content_bytes_len,
             request.content_type,
             request.body.gets
           )
@@ -57,7 +63,7 @@ module TCellAgent
 
 
       attr_accessor :remote_address, :method, :location, :route_id, :session_id, :user_id, :transaction_id,
-        :request_content_len, :get_dict, :post_dict, :body_dict, :cookie_dict, :response_content_len, :response_code,
+        :request_content_bytes_len, :get_dict, :post_dict, :body_dict, :cookie_dict, :response_content_bytes_len, :response_code,
         :user_agent, :path_parameters
 
       attr_accessor :request_headers, :response_headers
@@ -65,8 +71,8 @@ module TCellAgent
       def initialize
         super
 
-        @request_content_len = 0
-        @response_content_len = 0
+        @request_content_bytes_len = 0
+        @response_content_bytes_len = 0
         @user_agent = nil
       end
 

data/lib/tcell_agent/servers/passenger.rb

@@ -4,7 +4,38 @@ PhusionPassenger::LoaderSharedHelpers.class_eval do
   def after_loading_app_code(options)
     tcell_after_loading_app_code(options)
 
-    TCellAgent.run_instrumentation("Passenger")
+    TCellAgent::Instrumentation.safe_block("Initial Passenger Instrumentation") do
+      # This runs in Passenger's AppPreloader (a process which is killed at some point)
+      # but it's still a good place to do the initial instrumentation so it's only sent once.
+      # Since this process doesn't receive any requests there is no need to run policy polling
+      # but we still need the event processor to send the startup events
+      original_policy_polling = TCellAgent.configuration.enable_policy_polling
+      TCellAgent.configuration.enable_policy_polling = false
+      TCellAgent.run_instrumentation("Passenger")
+      TCellAgent.configuration.enable_policy_polling = original_policy_polling
+    end
+  end
+
+  alias_method :tcell_before_handling_requests, :before_handling_requests
+  def before_handling_requests(forked, options)
+    result_if_needed = tcell_before_handling_requests(forked, options)
+
+    TCellAgent.run_instrumentation("Passenger", false)
+
+    result_if_needed
+  end
+
+end
+
+# Passenger's parent process is known as the AppPreloader, the problem is this
+# process seems to disappear at some point taking the event processor with it.
+# This will give every child process its own event manager to avoid the dependency
+# on this disappearing process
+class << TCellAgent::Agent
+
+  alias_method :tcell_is_parent_process?, :is_parent_process?
+  def is_parent_process?
+    true
   end
 
 end

data/lib/tcell_agent/start_background_thread.rb

@@ -9,7 +9,7 @@ if (TCellAgent.configuration.disable_all == false)
     #require 'tcell_agent/sinatra' if defined?(Sinatra)
     require 'tcell_agent/rails' if defined?(Rails)
 
-    def self.run_instrumentation(server_name)
+    def self.run_instrumentation(server_name, send_startup_events=true)
 
       require 'tcell_agent/rails/on_start' if defined?(Rails)
 
@@ -18,7 +18,7 @@ if (TCellAgent.configuration.disable_all == false)
         TCellAgent.thread_agent.start
       end
 
-      if TCellAgent.configuration.should_instrument?
+      if send_startup_events && TCellAgent.configuration.should_instrument?
         Thread.abort_on_exception = TCellAgent.configuration.raise_exceptions
         Thread.new do
 
@@ -117,7 +117,6 @@ if (TCellAgent.configuration.disable_all == false)
             end
           end
         end
-
       end
 
     end

data/lib/tcell_agent/utils/queue_with_timeout.rb

@@ -74,7 +74,7 @@ module TCellAgent
           if condition_predicate.call
             return yield
 
-          elsif deadline == :never || deadline > Time.now
+          elsif :never == deadline || deadline > Time.now
             next
 
           else

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.23"
+  VERSION = "0.2.24"
 end

data/spec/lib/tcell_agent/agent/policy_manager_spec.rb

@@ -351,7 +351,7 @@ module TCellAgent
 
                 logger = double("logger")
                 expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:warn).with("757: unexpected token at 'bad_json'")
+                expect(logger).to receive(:warn).with(/unexpected token at 'bad_json'/)
                 expect_any_instance_of(TCellAgent::Agent).to_not receive(:processPolicyJson)
 
                 agent = TCellAgent::Agent.new(Process.pid)

data/spec/lib/tcell_agent/policies/appsensor/database_sensor_spec.rb

@@ -56,7 +56,7 @@ module TCellAgent
         context "with enabled sensor" do
           context "records is less than limit" do
             it "should not send event" do
-              sensor = RequestSizeSensor.new({
+              sensor = DatabaseSensor.new({
                 "enabled" => true,
                 "large_result" => { "limit" => 10},
                 "exclude_routes" => []
@@ -90,7 +90,6 @@ module TCellAgent
                 {
                   "event_type" => "as",
                   "dp" => DatabaseSensor::DP_CODE,
-                  "param" => nil,
                   "remote_addr" => "ip_address",
                   "rid" => "route_id",
                   "m" => "get",
@@ -146,7 +145,6 @@ module TCellAgent
                   {
                     "event_type" => "as",
                     "dp" => DatabaseSensor::DP_CODE,
-                    "param" => nil,
                     "remote_addr" => "ip_address",
                     "rid" => "route_id",
                     "m" => "get",

data/spec/lib/tcell_agent/policies/appsensor/misc_sensor_spec.rb

@@ -173,9 +173,7 @@ module TCellAgent
               expect(TCellAgent).to receive(:send_event).with({
                 "event_type"=>"as",
                 "dp"=>"excsrf",
-                "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken",
-                "remote_addr"=>nil,
-                "m"=>nil
+                "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken"
               })
 
               sensor.csrf_rejected(tcell_data, @exception_class)
@@ -195,9 +193,7 @@ module TCellAgent
                   "event_type"=>"as",
                   "dp"=>"excsrf",
                   "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken",
-                  "remote_addr"=>nil,
-                  "rid"=>"route_id",
-                  "m"=>nil
+                  "rid"=>"route_id"
                 })
 
                 sensor.csrf_rejected(tcell_data, @exception_class)
@@ -235,9 +231,7 @@ module TCellAgent
                     "event_type"=>"as",
                     "dp"=>"excsrf",
                     "param"=>"TCellAgent::Policies::FakeInvalidAuthenticityToken",
-                    "remote_addr"=>nil,
-                    "rid"=>"route_id",
-                    "m"=>nil
+                    "rid"=>"route_id"
                   })
 
                   sensor.csrf_rejected(tcell_data, @exception_class)
@@ -359,9 +353,7 @@ module TCellAgent
               expect(TCellAgent).to receive(:send_event).with({
                 "event_type"=>"as",
                 "dp"=>"exsql",
-                "param"=>"TCellAgent::Policies::FakeStatementInvalid",
-                "remote_addr"=>nil,
-                "m"=>nil
+                "param"=>"TCellAgent::Policies::FakeStatementInvalid"
               })
 
               sensor.sql_exception_detected(tcell_data, @exception)
@@ -381,9 +373,7 @@ module TCellAgent
                   "event_type"=>"as",
                   "dp"=>"exsql",
                   "param"=>"TCellAgent::Policies::FakeStatementInvalid",
-                  "remote_addr"=>nil,
-                  "rid"=>"route_id",
-                  "m"=>nil
+                  "rid"=>"route_id"
                 })
 
                 sensor.sql_exception_detected(tcell_data, @exception)
@@ -421,9 +411,7 @@ module TCellAgent
                     "event_type"=>"as",
                     "dp"=>"exsql",
                     "param"=>"TCellAgent::Policies::FakeStatementInvalid",
-                    "remote_addr"=>nil,
-                    "rid"=>"route_id",
-                    "m"=>nil
+                    "rid"=>"route_id"
                   })
 
                   sensor.sql_exception_detected(tcell_data, @exception)

data/spec/lib/tcell_agent/policies/appsensor/request_size_sensor_spec.rb

@@ -50,18 +50,27 @@ module TCellAgent
         context "with disabled sensor" do
           it "should not send event" do
             sensor = RequestSizeSensor.new({"enabled" => false})
-
-            expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-            sensor.check({}, 10)
+            meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+            meta.remote_address = "remote_address"
+            meta.method = "get"
+            meta.location = "location"
+            meta.route_id = "route_id"
+            meta.session_id = "session_id"
+            meta.user_id = "user_id"
+            meta.transaction_id = "transaction_id"
+            meta.request_content_bytes_len = 1024
+
+            expect(TCellAgent).to_not receive(:send_event)
+            sensor.check(meta)
           end
         end
 
         context "with enabled sensor" do
-          context "size is nil" do
+          context "size is zero" do
             it "should not send event" do
               sensor = RequestSizeSensor.new({
                 "enabled" => true,
-                "limit" => 2048,
+                "limit" => 1,
                 "exclude_routes" => []
               })
 
@@ -73,9 +82,35 @@ module TCellAgent
               meta.session_id = "session_id"
               meta.user_id = "user_id"
               meta.transaction_id = "transaction_id"
+              meta.request_content_bytes_len = 0
 
-              expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-              sensor.check(meta, nil)
+              expect(TCellAgent).to_not receive(:send_event)
+              sensor.check(meta)
+            end
+          end
+
+          context "size is too small" do
+            context "by half a KiB" do
+              it "should not send event" do
+                sensor = RequestSizeSensor.new({
+                  "enabled" => true,
+                  "limit" => 1,
+                  "exclude_routes" => []
+                })
+
+                meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+                meta.remote_address = "remote_address"
+                meta.method = "get"
+                meta.location = "location"
+                meta.route_id = "route_id"
+                meta.session_id = "session_id"
+                meta.user_id = "user_id"
+                meta.transaction_id = "transaction_id"
+                meta.request_content_bytes_len = 512
+
+                expect(TCellAgent).to_not receive(:send_event)
+                sensor.check(meta)
+              end
             end
           end
 
@@ -83,7 +118,7 @@ module TCellAgent
             it "should not send event" do
               sensor = RequestSizeSensor.new({
                 "enabled" => true,
-                "limit" => 2048,
+                "limit" => 1,
                 "exclude_routes" => []
               })
 
@@ -95,18 +130,42 @@ module TCellAgent
               meta.session_id = "session_id"
               meta.user_id = "user_id"
               meta.transaction_id = "transaction_id"
+                meta.request_content_bytes_len = 1024
 
-              expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-              sensor.check(meta, 1024)
+              expect(TCellAgent).to_not receive(:send_event)
+              sensor.check(meta)
             end
           end
 
           context "size is too big" do
+            context "by half a KiB" do
+              it "should not send event" do
+                sensor = RequestSizeSensor.new({
+                  "enabled" => true,
+                  "limit" => 1,
+                  "exclude_routes" => ["excluded_route_id"]
+                })
+
+                meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+                meta.remote_address = "remote_address"
+                meta.method = "get"
+                meta.location = "location"
+                meta.route_id = "excluded_route_id"
+                meta.session_id = "session_id"
+                meta.user_id = "user_id"
+                meta.transaction_id = "transaction_id"
+                meta.request_content_bytes_len = 1024 + 512
+
+                expect(TCellAgent).to_not receive(:send_event)
+                sensor.check(meta)
+              end
+            end
+
             context "route_id is excluded" do
               it "should not send event" do
                 sensor = RequestSizeSensor.new({
                   "enabled" => true,
-                  "limit" => 1024,
+                  "limit" => 1,
                   "exclude_routes" => ["excluded_route_id"]
                 })
 
@@ -118,9 +177,10 @@ module TCellAgent
                 meta.session_id = "session_id"
                 meta.user_id = "user_id"
                 meta.transaction_id = "transaction_id"
+                meta.request_content_bytes_len = 2048
 
-                expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-                sensor.check(meta, 2048)
+                expect(TCellAgent).to_not receive(:send_event)
+                sensor.check(meta)
               end
             end
 
@@ -128,7 +188,7 @@ module TCellAgent
               it "should send event" do
                 sensor = RequestSizeSensor.new({
                   "enabled" => true,
-                  "limit" => 1024,
+                  "limit" => 1,
                   "exclude_routes" => []
                 })
 
@@ -140,25 +200,36 @@ module TCellAgent
                 meta.session_id = "session_id"
                 meta.user_id = "user_id"
                 meta.transaction_id = "transaction_id"
+                meta.request_content_bytes_len = 2048
 
                 expect(TCellAgent).to receive(:send_event).with(
                   {
                     "event_type" => "as",
                     "dp" => RequestSizeSensor::DP_UNUSUAL_REQUEST_SIZE,
-                    "param" => nil,
                     "remote_addr" => "remote_address",
                     "m" => "get",
                     "meta" => {"sz" => 2048},
                     "rid" => "excluded_route_id"
                   }
                 )
-                sensor.check(meta, 2048)
+                sensor.check(meta)
               end
             end
           end
 
         end
       end
+
+      context "#get_content_length" do
+        it "should return the request size" do
+          sensor = RequestSizeSensor.new({"enabled" => false})
+          meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+          meta.request_content_bytes_len = 1024
+          meta.response_content_bytes_len = 2048
+
+          expect(sensor.get_content_length(meta)).to eq(1024)
+        end
+      end
     end
 
   end

data/spec/lib/tcell_agent/policies/appsensor/response_size_sensor_spec.rb

@@ -50,14 +50,23 @@ module TCellAgent
         context "with disabled sensor" do
           it "should not send event" do
             sensor = ResponseSizeSensor.new({"enabled" => false})
-
-            expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-            sensor.check({}, 10)
+            meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+            meta.remote_address = "remote_address"
+            meta.method = "get"
+            meta.location = "location"
+            meta.route_id = "route_id"
+            meta.session_id = "session_id"
+            meta.user_id = "user_id"
+            meta.transaction_id = "transaction_id"
+            meta.response_content_bytes_len = 1024
+
+            expect(TCellAgent).to_not receive(:send_event)
+            sensor.check(meta)
           end
         end
 
         context "with enabled sensor" do
-          context "size is nil" do
+          context "size is zero" do
             it "should not send event" do
               sensor = ResponseSizeSensor.new({
                 "enabled" => true,
@@ -73,9 +82,35 @@ module TCellAgent
               meta.session_id = "session_id"
               meta.user_id = "user_id"
               meta.transaction_id = "transaction_id"
+              meta.response_content_bytes_len = 0
+
+              expect(TCellAgent).to_not receive(:send_event)
+              sensor.check(meta)
+            end
+          end
+
+          context "size is too small" do
+            context "by half a KiB" do
+              it "should not send event" do
+                sensor = ResponseSizeSensor.new({
+                  "enabled" => true,
+                  "limit" => 1,
+                  "exclude_routes" => []
+                })
+
+                meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+                meta.remote_address = "remote_address"
+                meta.method = "get"
+                meta.location = "location"
+                meta.route_id = "route_id"
+                meta.session_id = "session_id"
+                meta.user_id = "user_id"
+                meta.transaction_id = "transaction_id"
+                meta.response_content_bytes_len = 512
 
-              expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-              sensor.check(meta, nil)
+                expect(TCellAgent).to_not receive(:send_event)
+                sensor.check(meta)
+              end
             end
           end
 
@@ -95,13 +130,44 @@ module TCellAgent
               meta.session_id = "session_id"
               meta.user_id = "user_id"
               meta.transaction_id = "transaction_id"
+              meta.response_content_bytes_len = 1024
 
-              expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-              sensor.check(meta, 1024)
+              expect(TCellAgent).to_not receive(:send_event)
+              sensor.check(meta)
             end
           end
 
           context "size is too big" do
+            context "by half a KiB" do
+              it "should not send event" do
+                sensor = ResponseSizeSensor.new({
+                  "enabled" => true,
+                  "limit" => 1,
+                  "exclude_routes" => []
+                })
+
+                meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+                meta.remote_address = "remote_address"
+                meta.method = "get"
+                meta.location = "location"
+                meta.route_id = "excluded_route_id"
+                meta.session_id = "session_id"
+                meta.user_id = "user_id"
+                meta.transaction_id = "transaction_id"
+                meta.response_content_bytes_len = 1024 + 512
+
+                expect(TCellAgent).to receive(:send_event).with(
+                  {"event_type"=>"as",
+                   "dp"=>"rspsz",
+                   "remote_addr"=>"remote_address",
+                   "m"=>"get",
+                   "meta"=>{"sz"=>1536},
+                   "rid"=>"excluded_route_id"}
+                )
+                sensor.check(meta)
+              end
+            end
+
             context "route_id is excluded" do
               it "should not send event" do
                 sensor = ResponseSizeSensor.new({
@@ -118,9 +184,10 @@ module TCellAgent
                 meta.session_id = "session_id"
                 meta.user_id = "user_id"
                 meta.transaction_id = "transaction_id"
+                meta.response_content_bytes_len = 2048
 
-                expect(TCellAgent::AppSensor::Sensor).to_not receive(:send_event)
-                sensor.check(meta, 2048)
+                expect(TCellAgent).to_not receive(:send_event)
+                sensor.check(meta)
               end
             end
 
@@ -128,7 +195,7 @@ module TCellAgent
               it "should send event" do
                 sensor = ResponseSizeSensor.new({
                   "enabled" => true,
-                  "limit" => 1024,
+                  "limit" => 1,
                   "exclude_routes" => []
                 })
 
@@ -140,17 +207,34 @@ module TCellAgent
                 meta.session_id = "session_id"
                 meta.user_id = "user_id"
                 meta.transaction_id = "transaction_id"
-
-                expect(TCellAgent::AppSensor::Sensor).to receive(:send_event).with(
-                  meta, ResponseSizeSensor::DP_UNUSUAL_RESPONSE_SIZE, nil, {"sz" => 2048}, nil, nil
+                meta.response_content_bytes_len = 2048
+
+                expect(TCellAgent).to receive(:send_event).with(
+                  {"event_type"=>"as",
+                   "dp"=>"rspsz",
+                   "remote_addr"=>"remote_address",
+                   "m"=>"get",
+                   "meta"=>{"sz"=>2048},
+                   "rid"=>"excluded_route_id"}
                 )
-                sensor.check(meta, 2048)
+                sensor.check(meta)
               end
             end
           end
         end
 
       end
+
+      context "#get_content_length" do
+        it "should return the response size" do
+          sensor = ResponseSizeSensor.new({"enabled" => false})
+          meta = TCellAgent::SensorEvents::AppSensorMetaEvent.new
+          meta.request_content_bytes_len = 1024
+          meta.response_content_bytes_len = 2048
+
+          expect(sensor.get_content_length(meta)).to eq(2048)
+        end
+      end
     end
 
   end

data/spec/lib/tcell_agent/policies/appsensor/user_agent_sensor_spec.rb

@@ -90,7 +90,6 @@ module TCellAgent
               expect(TCellAgent).to receive(:send_event).with({
                 "event_type"=>"as",
                 "dp"=>UserAgentSensor::DP_CODE,
-                "param"=>nil,
                 "remote_addr"=>"remote_address",
                 "m"=>"get",
                 "rid"=>"route_id"
@@ -106,7 +105,6 @@ module TCellAgent
                 expect(TCellAgent).to receive(:send_event).with({
                   "event_type"=>"as",
                   "dp"=>UserAgentSensor::DP_CODE,
-                  "param"=>nil,
                   "remote_addr"=>"remote_address",
                   "m"=>"get",
                   "rid"=>"route_id"
@@ -133,7 +131,6 @@ module TCellAgent
                   expect(TCellAgent).to receive(:send_event).with({
                     "event_type"=>"as",
                     "dp"=>UserAgentSensor::DP_CODE,
-                    "param"=>nil,
                     "remote_addr"=>"remote_address",
                     "m"=>"get",
                     "rid"=>"route_id"
@@ -151,7 +148,6 @@ module TCellAgent
               expect(TCellAgent).to receive(:send_event).with({
                 "event_type"=>"as",
                 "dp"=>UserAgentSensor::DP_CODE,
-                "param"=>nil,
                 "remote_addr"=>"remote_address",
                 "m"=>"get",
                 "rid"=>"route_id"

data/spec/lib/tcell_agent/rails/middleware/appsensor_middleware_spec.rb

@@ -99,7 +99,6 @@ module TCellAgent
                   "event_type"=>"as",
                   "dp"=>"xss",
                   "param"=>"xyz",
-                  "remote_addr"=>nil,
                   "rid"=>"myrouteid",
                   "m"=>"GET",
                   "pattern"=>"1",
@@ -115,7 +114,6 @@ module TCellAgent
                   "event_type"=>"as",
                   "dp"=>"xss",
                   "param"=>"xyz",
-                  "remote_addr"=>nil,
                   "rid"=>"myrouteid",
                   "m"=>"GET",
                   "pattern"=>"1",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcell_agent
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.2.24
 platform: ruby
 authors:
 - Garrett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-27 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client