tcell_agent 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38bd348af6afc0394baa2b21028297f52c8bd869
-  data.tar.gz: 3a0cd72fe8d1c792a13a4a73492da78d2b773b13
+  metadata.gz: ffa24423fa841f2a9bdb3b19d44b1250ba2bc4ff
+  data.tar.gz: ae260430c31ff45f822cf49efd0735664a181a8c
 SHA512:
-  metadata.gz: cd5eb354fe88c5822692bb5e74194d56f67645d92910e14f24d07d27c128735b5750d84a567e7a9dd4a2558c5af1b71f41ec92c47c9db1e5f4e1efc6c731d7f2
-  data.tar.gz: c570a523bdb36c1aebe4fcf457ececc053e3395cb56bc7f3fbc59d8100897fcda06a8a4fe0447f62acdee239ca4fba601c93892b92ea3d4a1a7c9f952915c9cb
+  metadata.gz: bfd43837abf1c1ee7297c09d6960f1bb37673ad0b3dd805b93980bed531f216e57e54384f532e74f3c1f5d435564b177925070d0ab24354fc68dfc06122f0f18
+  data.tar.gz: 0b745e26beb71868ede7f5703a7292462d07c830a3374a0e2a98a3ddedb655695a7b2320a0bbf222926bd3bbeba7dc8462621cd52d465e3295e25a69d25a66e6

data/lib/tcell_agent/agent/event_processor.rb

@@ -51,6 +51,13 @@ module TCellAgent
       @event_processor_thread && @event_processor_thread.alive?
     end
 
+    def stop_event_processor
+      TCellAgent.logger.debug("Stopping event processor thread")
+      if @event_processor_thread && @event_processor_thread.alive?
+        @event_processor_thread.exit
+      end
+    end
+
     def start_event_processor(send_empties=true)
       return if TCellAgent.configuration.should_start_event_manager? == false
 
@@ -247,6 +254,13 @@ module TCellAgent
       @start_metrics_event_thread && @start_metrics_event_thread.alive?
     end
 
+    def stop_metrics_event_thread
+      TCellAgent.logger.debug("Stopping metrics event thread")
+      if @start_metrics_event_thread && @start_metrics_event_thread.alive?
+        @start_metrics_event_thread.exit
+      end
+    end
+
     def start_metrics_event_thread
       return if TCellAgent.configuration.should_consume_event? == false
       @metrics_event_thread = Thread.new do

data/lib/tcell_agent/agent/policy_manager.rb

@@ -42,6 +42,13 @@ module TCellAgent
       @policy_polling_thread && @policy_polling_thread.alive?
     end
 
+    def stop_policy_polling
+      TCellAgent.logger.debug("Stopping policy polling thread")
+      if @policy_polling_thread && @policy_polling_thread.alive?
+        @policy_polling_thread.exit
+      end
+    end
+
     def start_policy_polling
       if TCellAgent.configuration.should_start_policy_poll? == true
         TCellAgent.logger.debug("Starting policy polling thread")
@@ -89,7 +96,7 @@ module TCellAgent
 
       if policy_jsons.key?("data")
         policy_data = policy_jsons["data"]
-      end              
+      end
 
       TCellAgent::PolicyTypes::ClassMap.each do | policy_type, policy_class |
         if (policy_jsons.key?(policy_type))
@@ -108,42 +115,66 @@ module TCellAgent
     end # end of processPolicyJson
 
     def cache(policy_name, policy)
-      cache_filename = TCellAgent.configuration.cache_filename
-      FileUtils.mkdir_p(File.dirname(cache_filename))
-      if TCellAgent.configuration.app_id
-        cache_filename = cache_filename + '.' + TCellAgent.configuration.app_id
-      end
-      policy_cache = policies_from_cachefile()
-      if !policy_cache
-        policy_cache = {}
-      end
-      policy_cache[policy_name] = policy
+      cache_filename = TCellAgent.configuration.cache_filename_with_app_id
+
       begin
-        File.write(cache_filename, JSON.dump(policy_cache))
+
+        FileUtils.mkdir_p(File.dirname(cache_filename))
+        f1 = open(cache_filename, File::RDWR|File::CREAT)
+
+        Timeout::timeout(0.100) { f1.flock(File::LOCK_EX) }
+
+        policy_cache = {}
+        existing_policy = f1.read
+
+        if !existing_policy.nil? && existing_policy != ""
+          policy_jsons = JSON.parse(existing_policy)
+          if policy_jsons
+            if policy_jsons.key?("result")
+              policy_cache = policy_jsons["result"]
+            else
+              policy_cache = policy_jsons
+            end
+          end
+        end
+        policy_cache[policy_name] = policy
+
+        f1.rewind
+        f1.puts( JSON.dump(policy_cache) )
+
       rescue Exception => e
         TCellAgent.logger.error(e.message)
+
+      ensure
+        f1.close unless f1.nil?
       end
+
     end
 
     def policies_from_cachefile
-      cache_filename = TCellAgent.configuration.cache_filename
-      if TCellAgent.configuration.app_id
-        cache_filename = cache_filename + '.' + TCellAgent.configuration.app_id
-      end
+      cache_filename = TCellAgent.configuration.cache_filename_with_app_id
       cache_exists = File.exist?(cache_filename)
+
       if !cache_exists
         return nil
       end
+
       begin
-        policy_filedata = open(cache_filename).read
+        f1 = File.open(cache_filename, File::RDONLY)
+        Timeout::timeout(1) { f1.flock( File::LOCK_SH ) }
+        policy_filedata = f1.read
+        f1.close
+
         policy_jsons = JSON.parse(policy_filedata)
         if policy_jsons.key?("result")
           return policy_jsons["result"]
         end
         return policy_jsons
+
       rescue Exception => e
         TCellAgent.logger.error(e.message)
       end
+
       return nil
     end
 

data/lib/tcell_agent/configuration.rb

@@ -95,11 +95,14 @@ module TCellAgent
       @js_agent_api_base_url ||= nil
       @js_agent_url ||= "https://api.tcell.io/tcellagent.min.js"
 
-      begin
-        @host_identifier = (Socket.gethostname() || "localhost")
-      rescue Exception
-        @host_identifier = "host_identifier_not_found"
+      if (@host_identifier == nil)
+        begin
+          @host_identifier = (Socket.gethostname() || "localhost")
+        rescue Exception
+          @host_identifier = "host_identifier_not_found"
+        end
       end
+
       @uuid = SecureRandom.uuid
 
       FileUtils::mkdir_p File.dirname(@cache_filename)
@@ -110,10 +113,19 @@ module TCellAgent
       end
     end
 
+    def cache_filename_with_app_id
+      if @app_id
+        "#{@cache_filename}.#{@app_id}"
+      else
+        @cache_filename
+      end
+    end
+
     def read_config_using_env
-      @app_id = ENV["TCELL_APP_ID"]
-      @api_key = ENV["TCELL_API_KEY"]
+      @app_id = ENV["TCELL_AGENT_APP_ID"]
+      @api_key = ENV["TCELL_AGENT_API_KEY"]
       @hmac_key = ENV["TCELL_HMAC_KEY"]
+      @host_identifier = ENV["TCELL_AGENT_HOST_IDENTIFIER"] || @host_identifier
       @tcell_api_url = ENV["TCELL_API_URL"]
       @tcell_input_url = ENV["TCELL_INPUT_URL"]
       @demomode = ENV["TCELL_DEMOMODE"] || @demomode
@@ -163,7 +175,8 @@ module TCellAgent
             @proxy_password = app_data["proxy_password"]
 
             @use_websockets = app_data["use_websockets"]
-            @host_identifier = app_data["host_identifier"]
+
+            @host_identifier = @host_identifier || app_data.fetch("host_identifier", @host_identifier)
             if (@host_identifier == nil)
               @host_identifier = (Socket.gethostname() || "localhost")
             end

data/lib/tcell_agent/policies/http_redirect_policy.rb

@@ -41,7 +41,7 @@ module TCellAgent
         end
         return true
       end
-      def enforce(target_url, current_host, current_path, method, status_code, remote_addr)
+      def enforce(target_url, current_host, current_path, method, route_id, status_code, remote_addr, session_id=nil)
         if @enabled == false
           return nil
         end
@@ -51,7 +51,7 @@ module TCellAgent
           return nil
         end
         begin
-          event = TCellAgent::SensorEvents::TCellRedirectSensorEvent.new(host, current_host, current_path, method, status_code, remote_addr)
+          event = TCellAgent::SensorEvents::TCellRedirectSensorEvent.new(host, current_host, current_path, method, route_id, status_code, remote_addr, session_id, nil)
           TCellAgent.send_event(event)
         rescue Exception => ie
           TCellAgent.logger.error("uncaught exception while creating redirect event: #{ie.message}")

data/lib/tcell_agent/rails.rb

@@ -18,7 +18,6 @@ require 'tcell_agent/rails/middleware/context_middleware'
 require 'tcell_agent/rails/settings_reporter'
 require 'tcell_agent/rails/dlp'
 
-require 'rails/all'
 
 require 'tcell_agent/userinfo'
 require 'cgi'
@@ -27,7 +26,6 @@ require 'thread'
 module TCellAgent
   class Railtie < Rails::Railtie
     initializer "tcell_agent.insert_middleware" do |app|
-        if TCellAgent.configuration.should_intercept_requests?
           app.config.to_prepare do
             require 'tcell_agent/devise' if defined?(Devise)
             require 'tcell_agent/rails/auth/devise' if defined?(Devise)
@@ -38,7 +36,6 @@ module TCellAgent
           app.config.middleware.insert_after(0, "TCellAgent::Instrumentation::Rails::Middleware::HeadersMiddleware")
           app.config.middleware.use "TCellAgent::Instrumentation::Rails::Middleware::BodyFilterMiddleware"
           app.config.middleware.use "TCellAgent::Instrumentation::Rails::Middleware::GlobalMiddleware"
-        end
     end
   end
 end

data/lib/tcell_agent/rails/auth/authlogic.rb

@@ -5,48 +5,53 @@ require 'tcell_agent/configuration'
 require 'tcell_agent/instrumentation'
 
 module TCellAgent
-    if defined?(Authlogic)
+  if defined?(Authlogic)
+    TCellAgent.logger.debug("Instrumenting Authlogic")
+    require 'tcell_agent/agent'
+    require 'tcell_agent/sensor_events/login_fraud'
+    Authlogic::Session::Base.class_eval do
+      alias_method :original_save, :save
+      def save(&block)
         if (TCellAgent.configuration.enabled && TCellAgent.configuration.should_intercept_requests?)
-            TCellAgent.logger.debug("Instrumenting Authlogic")
-            require 'tcell_agent/agent'
-            require 'tcell_agent/sensor_events/login_fraud'
-            Authlogic::Session::Base.class_eval do
-              alias_method :original_save, :save
-              def save(&block)
-                user_logged_in_before = (user != nil)
-                success = original_save
-                user_logged_in_after = (user != nil)
-                TCellAgent::Instrumentation.safe_block("Authlogic login info") {
+          user_logged_in_before = (user != nil)
+          success = original_save
+          user_logged_in_after = (user != nil)
+          TCellAgent::Instrumentation.safe_block("Authlogic login info") {
 
-                    login_fraud_policy = TCellAgent.policy(TCellAgent::PolicyTypes::LoginFraud)
-                    if (login_fraud_policy && login_fraud_policy.enabled)
-                        user_id = nil
-                        TCellAgent::Instrumentation.safe_block("getting userid for login form") {
-                            user_id = self.send(self.class.login_field.to_sym)
-                        }
-                        if (user_logged_in_before && user_logged_in_after)
-                            #password changed or logged in as another user
-                        elsif (!user_logged_in_before && !user_logged_in_after)
-                            if (login_fraud_policy.login_failed_enabled)
-                                request = Authlogic::Session::Base.controller.request
-                                response = Authlogic::Session::Base.controller.response
-                                hmac_session_id = request.env["tcell.request_data"].hmac_session_id
-                                event = TCellAgent::SensorEvents::LoginFailure.new(request, response, user_id, hmac_session_id)
-                                TCellAgent.send_event(event)
-                            end       
-                        elsif (!user_logged_in_before && user_logged_in_after)
-                            if (login_fraud_policy.login_success_enabled)
-                                request = Authlogic::Session::Base.controller.request
-                                response = Authlogic::Session::Base.controller.response
-                                hmac_session_id = request.env["tcell.request_data"].hmac_session_id
-                                event = TCellAgent::SensorEvents::LoginSuccess.new(request, response, user_id, hmac_session_id)
-                                TCellAgent.send_event(event)
-                            end
-                        end
-                    end
-                }
+            login_fraud_policy = TCellAgent.policy(TCellAgent::PolicyTypes::LoginFraud)
+            if (login_fraud_policy && login_fraud_policy.enabled)
+              user_id = nil
+              TCellAgent::Instrumentation.safe_block("getting userid for login form") {
+                user_id = self.send(self.class.login_field.to_sym)
+              }
+              if (user_logged_in_before && user_logged_in_after)
+                #password changed or logged in as another user
+              elsif (!user_logged_in_before && !user_logged_in_after)
+                if (login_fraud_policy.login_failed_enabled)
+                  request = Authlogic::Session::Base.controller.request
+                  response = Authlogic::Session::Base.controller.response
+                  hmac_session_id = request.env["tcell.request_data"].hmac_session_id
+                  event = TCellAgent::SensorEvents::LoginFailure.new(request, response, user_id, hmac_session_id)
+                  TCellAgent.send_event(event)
+                end
+              elsif (!user_logged_in_before && user_logged_in_after)
+                if (login_fraud_policy.login_success_enabled)
+                  request = Authlogic::Session::Base.controller.request
+                  response = Authlogic::Session::Base.controller.response
+                  hmac_session_id = request.env["tcell.request_data"].hmac_session_id
+                  event = TCellAgent::SensorEvents::LoginSuccess.new(request, response, user_id, hmac_session_id)
+                  TCellAgent.send_event(event)
+                end
               end
-            end 
+            end
+          }
+
+          success
+
+        else
+          original_save
         end # if instrument
-    end # if Authlogic
-end
+      end
+    end
+  end # if Authlogic
+end

data/lib/tcell_agent/rails/auth/devise.rb

@@ -1,24 +1,26 @@
 module TCellAgent
   if defined?(Devise)
-    if (TCellAgent.configuration.enabled && TCellAgent.configuration.should_intercept_requests?)
-      TCellAgent.logger.debug("Instrumenting Devise")
 
-      require 'tcell_agent/agent'
-      require 'tcell_agent/sensor_events/login_fraud'
-      require 'tcell_agent/sensor_events/app_sensor'
-      require 'tcell_agent/policies/appsensor_policy'
+    TCellAgent.logger.debug("Instrumenting Devise")
 
-      Devise::SessionsController.class_eval do
+    require 'tcell_agent/agent'
+    require 'tcell_agent/sensor_events/login_fraud'
+    require 'tcell_agent/sensor_events/app_sensor'
+    require 'tcell_agent/policies/appsensor_policy'
 
-        after_filter :log_failed_login, :only => :new
-        alias_method :original_new, :new
-        def new
-          original_new
-        end
+    Devise::SessionsController.class_eval do
+
+      after_filter :log_failed_login, :only => :new
+      alias_method :original_new, :new
+      def new
+        original_new
+      end
+
+      alias_method :original_create, :create
+      def create(&block)
+        results = original_create(&block)
 
-       alias_method :original_create, :create
-        def create(&block)
-          results = original_create(&block)
+        if (TCellAgent.configuration.enabled && TCellAgent.configuration.should_intercept_requests?)
           TCellAgent::Instrumentation.safe_block("Devise login successful") {
             tcell_username = _get_tcell_username
             login_fraud_policy = TCellAgent.policy(TCellAgent::PolicyTypes::LoginFraud)
@@ -27,30 +29,33 @@ module TCellAgent
               request.env["tcell.request_data"].user_id = TCellAgent::UserInformation.getUserFromRequest(request)
               user_id = tcell_username || request.env["tcell.request_data"].user_id
               event = TCellAgent::SensorEvents::LoginSuccess.new(request, response, user_id, hmac_session_id)
-              TCellAgent.send_event(event)         
+              TCellAgent.send_event(event)
             end
           }
-          results
         end
 
-        def _get_tcell_username
-          _tcell_username = nil
-          TCellAgent::Instrumentation.safe_block("devise login - get username") {
-            keys = resource_class.authentication_keys.dup
-            user_params = request.POST.fetch("user",{})
-            keys.each do |key|
-              next_usename = user_params.fetch(key, nil)
-              if next_usename
-                _tcell_username ||= ""
-                _tcell_username += next_usename
-              end
+        results
+      end
+
+      def _get_tcell_username
+        _tcell_username = nil
+        TCellAgent::Instrumentation.safe_block("devise login - get username") {
+          keys = resource_class.authentication_keys.dup
+          user_params = request.POST.fetch("user",{})
+          keys.each do |key|
+            next_usename = user_params.fetch(key, nil)
+            if next_usename
+              _tcell_username ||= ""
+              _tcell_username += next_usename
             end
-          }
-          _tcell_username
-        end
+          end
+        }
+        _tcell_username
+      end
 
-        private
-        def log_failed_login
+      private
+      def log_failed_login
+        if (TCellAgent.configuration.enabled && TCellAgent.configuration.should_intercept_requests?)
           TCellAgent::Instrumentation.safe_block("Devise login failed") {
             tcell_username = _get_tcell_username
             login_fraud_policy = TCellAgent.policy(TCellAgent::PolicyTypes::LoginFraud)
@@ -78,12 +83,13 @@ module TCellAgent
               TCellAgent.send_event(event)
             end
           }
-        end 
+        end
+      end
 
-        def failed_login?
-          (options = env["warden.options"]) && options[:action] == "unauthenticated"
-        end 
+      def failed_login?
+        (options = env["warden.options"]) && options[:action] == "unauthenticated"
       end
-    end # if instrument
+    end
+
   end #if defined devise
-end
+end

data/lib/tcell_agent/rails/dlp.rb

@@ -2,7 +2,7 @@
 
 require 'tcell_agent/authlogic' if defined?(Authlogic)
 require 'tcell_agent/devise' if defined?(Devise)
-      
+
 require 'rails'
 require 'uri'
 require 'tcell_agent/logger'
@@ -22,9 +22,6 @@ require 'tcell_agent/rails/middleware/context_middleware'
 
 require 'tcell_agent/rails/routes'
 require 'tcell_agent/rails/settings_reporter'
-require 'tcell_agent/rails/dlp'
-
-require 'rails/all'
 
 require 'tcell_agent/userinfo'
 require 'cgi'
@@ -53,55 +50,82 @@ require 'thread'
 
 require 'tcell_agent/configuration'
 
-if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? && TCellAgent.configuration.should_intercept_requests?
 
+
+  module TCellAgent
+    class MyRailtie < Rails::Railtie
+      initializer 'activeservice.autoload', :after => :set_autoload_paths do |app|
+        def database_exists?
+          database_yaml = "#{Rails.root}/config/database.yml"
+          File.exists?database_yaml
+        end
+
+if (database_exists?)
   class ActiveRecord::Base
     # after_initialize do |user|
     #   puts "You have initialized an object!"
     #   puts "ASDF"
     # end
     after_find do |record|
-      database_name = self.class.connection_config().fetch(:database,"*").split('/').last
-      dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-      if dlp_policy
-        request_env = TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS.fetch(Thread.current.object_id, nil)
-        if request_env
-          tcell_context = request_env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-          if tcell_context
-            model = record.class
-            column_names = model.columns.map { |col| col.name }
-            if (dlp_policy.database_discovery_enabled)
-              TCellAgent.discover_database_fields(tcell_context.route_id, database_name,"*",model.table_name, column_names)
-            end
-            model.columns.each do |col|
-              #puts "#{model.table_name} .. #{col.name}"
-              action_objs = dlp_policy.get_actions_for_table(database_name, "*", model.table_name, col.name, tcell_context.route_id)
-              if action_objs
-                action_objs.each do |action_obj|
-                  tcell_context.add_response_db_filter(record[col.name.to_sym], action_obj, database_name, "*", model.table_name, col.name)
+      if TCellAgent.configuration.enabled &&
+          TCellAgent.configuration.should_instrument? &&
+          TCellAgent.configuration.should_intercept_requests?
+
+        database_name = self.class.connection_config().fetch(:database,"*").split('/').last
+        dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+        if dlp_policy
+          request_env = TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS.fetch(Thread.current.object_id, nil)
+          if request_env
+            tcell_context = request_env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
+            if tcell_context
+              model = record.class
+              column_names = model.columns.map { |col| col.name }
+              if (dlp_policy.database_discovery_enabled)
+                TCellAgent.discover_database_fields(tcell_context.route_id, database_name,"*",model.table_name, column_names)
+              end
+              model.columns.each do |col|
+                #puts "#{model.table_name} .. #{col.name}"
+                action_objs = dlp_policy.get_actions_for_table(database_name, "*", model.table_name, col.name, tcell_context.route_id)
+                if action_objs
+                  action_objs.each do |action_obj|
+                    tcell_context.add_response_db_filter(record[col.name.to_sym], action_obj, database_name, "*", model.table_name, col.name)
+                  end
                 end
               end
             end
           end
-        end
+        end # /if dlp_policy
+      end # /enabled
+    end # /after_find
+  end # /class
+end
+
       end
     end
   end
 
-  # - Request
-  # -   Session Id event
-  # -   Session Id redact
-  # -   Session Id hash
-  # -   Session Id mask
-  # -   Database-Stuff - [event, redact]
-  # 
-  # - Log
-  #
 
-  module TCellAgent
-    module Policies
-      class DataLossPolicy
-        def log_enforce(tcell_context, sanitize_string)
+
+
+
+# - Request
+# -   Session Id event
+# -   Session Id redact
+# -   Session Id hash
+# -   Session Id mask
+# -   Database-Stuff - [event, redact]
+# 
+# - Log
+#
+
+module TCellAgent
+  module Policies
+    class DataLossPolicy
+
+      def log_enforce(tcell_context, sanitize_string)
+        if TCellAgent.configuration.enabled &&
+            TCellAgent.configuration.should_instrument? &&
+            TCellAgent.configuration.should_intercept_requests? &&
           if (tcell_context && tcell_context.session_id)
             session_id_actions = self.get_actions_for_session_id
             if session_id_actions
@@ -121,17 +145,23 @@ if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrumen
               if send_event
                 TCellAgent.send_event(
                   TCellAgent::SensorEvents::DlpEvent.new(
-                    tcell_context.route_id, 
-                    tcell_context.uri, 
+                    tcell_context.route_id,
+                    tcell_context.uri,
                     TCellAgent::SensorEvents::DlpEvent::FOUND_IN_LOG
                     ).for_framework(TCellAgent::SensorEvents::DlpEvent::FRAMEWORK_VARIABLE_SESSION_ID)
                 )
               end
             end
           end
-          sanitize_string
         end
-        def response_body_enforce(tcell_context, sanitize_string)
+
+        sanitize_string
+      end
+
+      def response_body_enforce(tcell_context, sanitize_string)
+        if TCellAgent.configuration.enabled &&
+            TCellAgent.configuration.should_instrument? &&
+            TCellAgent.configuration.should_intercept_requests? &&
           if (tcell_context && tcell_context.session_id)
             session_id_actions = self.get_actions_for_session_id
             if session_id_actions
@@ -152,67 +182,79 @@ if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrumen
             if send_event
               TCellAgent.send_event(
                 TCellAgent::SensorEvents::DlpEvent.new(
-                  tcell_context.route_id, 
-                  tcell_context.uri, 
+                  tcell_context.route_id,
+                  tcell_context.uri,
                   TCellAgent::SensorEvents::DlpEvent::FOUND_IN_BODY
                   ).for_framework(TCellAgent::SensorEvents::DlpEvent::FRAMEWORK_VARIABLE_SESSION_ID)
               )
             end
           end
-          sanitize_string
         end
+
+        sanitize_string
       end
     end
   end
+end
+
+module TCellAgent
+  ActiveSupport.on_load(:action_controller) do
+    ActionController::Base.class_eval do
+      around_filter :global_request_logging
+      def global_request_logging
+        begin
+
+          yield
+
+          if TCellAgent.configuration.enabled &&
+              TCellAgent.configuration.should_instrument? &&
+              TCellAgent.configuration.should_intercept_requests?
+
+            TCellAgent::Instrumentation.safe_block("Running DLP Logging Filters") {
+              tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
+              if tcell_context
+                response.body = tcell_context.filter_body(response.body)
+              end
+            }
 
-  module TCellAgent
-      ActiveSupport.on_load(:action_controller) do
-        ActionController::Base.class_eval do
-          around_filter :global_request_logging
-          def global_request_logging 
-            begin 
-              yield
-              TCellAgent::Instrumentation.safe_block("Running DLP Logging Filters") {
-                tcell_context = request.env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-                if tcell_context
-                  response.body = tcell_context.filter_body(response.body)
-                end
-              }
-            end
           end
         end
       end
+    end
   end
+end
 
-  class Logger
-    alias_method :tcell_old_add, :add
-    def add(severity, message = nil, progname = nil, &block)
-      if severity < self.level
-        tcell_old_add(severity, message, progname)
-
-      else
-        progname ||= @progname
-        if message.nil?
-          if block_given?
-            message = yield
-          else
-            message = progname
-            progname = @progname
-          end
+
+class Logger
+  alias_method :tcell_old_add, :add
+  def add(severity, message = nil, progname = nil, &block)
+    if TCellAgent.configuration.enabled &&
+        TCellAgent.configuration.should_instrument? &&
+        TCellAgent.configuration.should_intercept_requests? &&
+        severity >= self.level
+
+      progname ||= @progname
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
         end
+      end
 
-        TCellAgent::Instrumentation.safe_block_no_log("Handling JSAgent add") {
-          dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
-          request_env = TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS.fetch(Thread.current.object_id, nil)
-          if message && dlp_policy && request_env
-            tcell_context = request_env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
-            if tcell_context
-              tcell_context.filter_log(message)
-            end
+      TCellAgent::Instrumentation.safe_block_no_log("Handling JSAgent add") {
+        dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DataLoss)
+        request_env = TCellAgent::Instrumentation::Rails::Middleware::ContextMiddleware::THREADS.fetch(Thread.current.object_id, nil)
+        if message && dlp_policy && request_env
+          tcell_context = request_env[TCellAgent::Instrumentation::Rails::Middleware::TCELL_ID]
+          if tcell_context
+            tcell_context.filter_log(message)
           end
-        }
-        tcell_old_add(severity, message, progname)
-      end
+        end
+      }
     end
+
+    tcell_old_add(severity, message, progname)
   end
 end