tcell_agent 2.0.0 → 2.5.0

data/lib/tcell_agent/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # See the file "LICENSE" for the full license governing this code.
 require 'fileutils'
 require 'json'
@@ -6,315 +8,118 @@ require 'socket'
 require 'securerandom'
 require 'uri'
 
-require 'tcell_agent/config/unknown_options'
-
 module TCellAgent
   class ConfigurationException < StandardError
   end
 
   class << self
     attr_accessor :configuration
+    attr_accessor :initializer_configuration
   end
 
   def self.configure
-    self.configuration ||= Configuration.new
-    yield(configuration)
-  end
-
-  class Configuration # rubocop:disable Metrics/ClassLength
-    attr_accessor :version,
-                  :app_id,
-                  :api_key,
-                  :hmac_key,
-                  :tcell_api_url,
-                  :tcell_input_url,
-                  :logging_options,
-                  :fetch_policies_from_tcell, :instrument_for_events,
-                  :preload_policy_filename,
-                  :host_identifier,
-                  :uuid,
-                  :event_batch_size_limit, :event_time_limit_seconds,
-                  :base_dir,
-                  :cache_filename,
-                  :cache_folder,
-                  :js_agent_api_base_url,
-                  :js_agent_url,
-                  :config_filename,
-                  :agent_log_dir,
-                  :max_data_ex_db_records_per_request,
-                  :agent_home_dir,
-                  :reverse_proxy,
-                  :reverse_proxy_ip_address_header,
-                  :log_file_name,
-                  :log_tag,
-                  :max_csp_header_bytes,
-                  :demomode,
-                  :allow_payloads,
-                  :password_hmac_key,
-                  :stdout_logger
-
-    attr_accessor :disable_all,
-                  :enabled,
-                  :enable_event_manager,       # false = Do not start the even manager
-                  :enable_event_consumer,      # false = Do not consume events, drop them
-                  :enable_policy_polling,      # false = Do not poll for policies
-                  :enable_instrumentation,     # false = Do not add instrumentation
-                  :enable_intercept_requests   # false = Do not insert middleware
+    require 'tcell_agent/config_initializer'
+    self.initializer_configuration ||= ConfigInitializer.new
 
-    attr_accessor :enabled_instrumentations
+    yield(initializer_configuration)
+  rescue NoMethodError => e
+    logger = TCellAgent::ModuleLogger.new(TCellAgent::RubyLogger.new, name)
+    logger.error("Error configuring tcell_agent with initializers: #{e}")
+  end
 
-    attr_accessor :exp_config_settings
+  class Configuration
+    # internal Ruby configurations
+    attr_accessor :disable_all
 
-    attr_accessor :disable_cmdi_exec_instrumentation # true = disable cmdi Kernel::exec instrumentation
+    # Common config returned by libtcellagent
+    attr_accessor :api_key, :app_id, :disabled_instrumentation, :enabled,
+                  :enable_intercept_requests, :fetch_policies_from_tcell, :hmac_key,
+                  :host_identifier, :instrument, :log_dir, :logging_options,
+                  :password_hmac_key, :reverse_proxy, :reverse_proxy_ip_address_header,
+                  :tcell_api_url
 
-    def should_start_event_manager?
-      @enabled && @enable_event_manager
-    end
+    # Ruby config returned by libtcellagent
+    attr_accessor :enable_policy_polling
 
     def should_start_policy_poll?
       @enabled && @enable_policy_polling && @fetch_policies_from_tcell # fetch_policies_from_tcel = legacy
     end
 
-    def should_instrument?
-      @enabled && @enable_instrumentation && @instrument_for_events # instrument_for_events = legacy
-    end
+    def should_instrument?(func = nil)
+      return false unless @enabled && @instrument # never instrument if disabled
+      return true if func.nil?                    # always instrument if enabled and nothing given
 
-    def should_intercept_requests?
-      @enabled && @enable_instrumentation && @enable_intercept_requests
+      !@disabled_instrumentation.include?(func)
     end
 
-    def should_instrument_doorkeeper?
-      if @enabled_instrumentations.key?('doorkeeper') || @enabled_instrumentations.key?(:doorkeeper)
-        !!(@enabled_instrumentations['doorkeeper'] || @enabled_instrumentations[:doorkeeper]) # rubocop:disable Style/DoubleNegation
-      else
-        true
-      end
-    end
-
-    def should_instrument_devise?
-      if @enabled_instrumentations.key?('devise') || @enabled_instrumentations.key?(:devise)
-        !!(@enabled_instrumentations['devise'] || @enabled_instrumentations[:devise]) # rubocop:disable Style/DoubleNegation
-      else
-        true
-      end
-    end
-
-    def should_instrument_authlogic?
-      if @enabled_instrumentations.key?('authlogic') || @enabled_instrumentations.key?(:authlogic)
-        !!(@enabled_instrumentations['authlogic'] || @enabled_instrumentations[:authlogic]) # rubocop:disable Style/DoubleNegation
-      else
-        true
-      end
-    end
-
-    def should_instrument_cmdi_exec?
-      !@disable_cmdi_exec_instrumentation
+    def should_intercept_requests?
+      @enabled && @enable_intercept_requests
     end
 
-    def initialize(filename = 'config/tcell_agent.config', _useapp = nil)
-      # These will be set when the agent starts up, to give rails initializers
-      # a chance to run
-      @cache_filename = nil
-      @agent_log_dir = nil
-      @log_tag = nil
-
-      @version = 0
-      @demomode = false
-
-      @fetch_policies_from_tcell = true
-      @instrument_for_events = true
-
+    def initialize
+      # ruby agent defaults
       @disable_all = false
-      @enabled = true
-      @enable_event_manager = true
-      @enable_policy_polling = true
-      @enable_instrumentation = true
-      @enable_intercept_requests = true
-
-      @enabled_instrumentations = {
-        :doorkeeper => true,
-        :devise => true,
-        :authlogic => true
-      }
-
-      @disable_cmdi_exec_instrumentation = false
-
-      @log_file_name = 'tcell_agent.log'
-
-      @event_batch_size_limit = 50
-      @event_time_limit_seconds = 15
-
-      @max_data_ex_db_records_per_request = 1000
-      @reverse_proxy = true
-      @reverse_proxy_ip_address_header = 'X-Forwarded-For'
-      @allow_payloads = true
-
-      @max_csp_header_bytes = nil
-      @password_hmac_key = nil
       @logging_options = {}
 
-      @agent_home_dir = ENV['TCELL_AGENT_HOME'] || File.join(Dir.getwd, 'tcell')
-      @cache_folder = File.join(@agent_home_dir, 'cache/')
-      @agent_log_dir = File.join(@agent_home_dir, 'logs')
-
-      @config_filename = ENV['TCELL_AGENT_CONFIG'] || File.join(Dir.getwd, filename)
-
-      read_config_from_file(@config_filename)
-      read_config_using_env
-
-      if @demomode
-        @event_batch_size_limit = 1
-        @event_time_limit_seconds = 2
-      end
-
-      @tcell_api_url ||= 'https://us.agent.tcell.insight.rapid7.com/api/v1'
-      @tcell_input_url ||= 'https://us.input.tcell.insight.rapid7.com/api/v1'
-      @js_agent_url ||= 'https://us.jsagent.tcell.insight.rapid7.com/tcellagent.min.js'
-
-      if @host_identifier.nil?
-        begin
-          @host_identifier = (Socket.gethostname || 'localhost')
-        rescue StandardError
-          @host_identifier = 'host_identifier_not_found'
-        end
-      end
-
-      @uuid = SecureRandom.uuid
+      check_for_disabled_instrumentation(get_config_file_name)
     end
 
-    def read_config_using_env
-      @app_id = ENV['TCELL_AGENT_APP_ID'] || @app_id
-      @api_key = ENV['TCELL_AGENT_API_KEY'] || @api_key
-      @hmac_key = ENV['TCELL_HMAC_KEY'] || @hmac_key
-      @password_hmac_key = ENV['TCELL_PASSWORD_HMAC_KEY'] || @password_hmac_key
-      @host_identifier = ENV['TCELL_AGENT_HOST_IDENTIFIER'] || @host_identifier
-      @tcell_api_url = ENV['TCELL_API_URL'] || @tcell_api_url
-      @tcell_input_url = ENV['TCELL_INPUT_URL'] || @tcell_input_url
-      @demomode = ENV['TCELL_DEMOMODE'] || @demomode
-
-      @agent_log_dir = ENV['TCELL_AGENT_LOG_DIR'] || @agent_log_dir
-      @log_file_name = ENV['TCELL_AGENT_LOG_FILENAME'] || @log_file_name
+    def get_config_file_path
+      return nil unless ENV['TCELL_AGENT_HOME']
+      return nil if ENV['TCELL_AGENT_CONFIG']
 
-      @logging_options['enabled'] = to_bool(ENV['TCELL_AGENT_LOG_ENABLED']) unless to_bool(ENV['TCELL_AGENT_LOG_ENABLED']).nil?
-      @logging_options['level'] = ENV['TCELL_AGENT_LOG_LEVEL'] || @logging_options['level'] unless @logging_options.nil?
-
-      @enabled = to_bool(ENV['TCELL_AGENT_ENABLED']) unless to_bool(ENV['TCELL_AGENT_ENABLED']).nil?
+      File.join(Dir.getwd, '/config/tcell_agent.config')
+    end
 
-      @allow_payloads = to_bool(ENV['TCELL_AGENT_ALLOW_PAYLOADS']) unless to_bool(ENV['TCELL_AGENT_ALLOW_PAYLOADS']).nil?
-      @disable_cmdi_exec_instrumentation = to_bool(ENV['TCELL_CMDI_EXEC_DISABLED']) || @disable_cmdi_exec_instrumentation
+    def get_config_file_name
+      ENV['TCELL_AGENT_CONFIG'] || File.join(Dir.getwd, '/config/tcell_agent.config')
     end
 
-    def read_config_from_file(filename)
+    def check_for_disabled_instrumentation(filename)
       return unless File.file?(filename)
 
       begin
-        config_text = File.open(filename).read
-        config = JSON.parse(config_text)
-
-        messages = TCellAgent::Config::Validate.get_unknown_options(config)
-        messages.each do |message|
-          puts message
-        end
+        config = JSON.parse(File.open(filename).read)
 
         if config['version'] == 1
-          # Required
-          app_data = config['applications'][0] # Default
-          @version = 1
-          @app_id = app_data['app_id']
-          @api_key = app_data['api_key']
-
-          # Optional
-          @preload_policy_filename = app_data.fetch('preload_policy_filename', nil)
-
-          @disable_all = app_data.fetch('disable_all', @disable_all)
-          @enabled = app_data.fetch('enabled', @enabled)
-
-          @enable_event_manager = app_data.fetch('enable_event_manager', @enable_event_manager)
-          @enable_policy_polling = app_data.fetch('enable_policy_polling', @enable_policy_polling)
-          @enable_instrumentation = app_data.fetch('enable_instrumentation', @enable_instrumentation)
-          @enable_intercept_requests = app_data.fetch('enable_intercept_requests', @enable_intercept_requests)
-          @fetch_policies_from_tcell = app_data.fetch('fetch_policies_from_tcell', @fetch_policies_from_tcell)
-          @instrument_for_events = app_data.fetch('instrument_for_events', @instrument_for_events)
-
-          @logging_options = app_data.fetch('logging_options', {})
-          @agent_log_dir = app_data.fetch('log_dir', @agent_log_dir)
-          @log_file_name = @logging_options['filename'] || @log_file_name
-
-          @tcell_api_url = app_data.fetch('tcell_api_url', @tcell_api_url)
-          @tcell_input_url = app_data.fetch('tcell_input_url', @tcell_input_url)
-
-          @max_csp_header_bytes = app_data.fetch('max_csp_header_bytes', @max_csp_header_bytes)
-
-          @allow_payloads = app_data.fetch(
-            'allow_payloads',
-            @allow_payloads
-          )
-
-          data_exposure = app_data.fetch('data_exposure', {})
-          @max_data_ex_db_records_per_request = data_exposure.fetch('max_data_ex_db_records_per_request', @max_data_ex_db_records_per_request)
-
-          @enabled_instrumentations = app_data.fetch('enabled_instrumentations', @enabled_instrumentations)
-
-          @reverse_proxy = app_data.fetch('reverse_proxy', @reverse_proxy)
-          @reverse_proxy_ip_address_header = app_data.fetch('reverse_proxy_ip_address_header', @reverse_proxy_ip_address_header)
-
-          @host_identifier = app_data.fetch('host_identifier', @host_identifier)
-          @hmac_key = app_data.fetch('hmac_key', @hmac_key)
-
-          @password_hmac_key = app_data.fetch('password_hmac_key', @password_hmac_key)
-
-          @uuid = SecureRandom.uuid
-          @uuid = 'secure-random-failed' if @uuid.nil?
-
-          if app_data.key?('js_agent_api_base_url')
-            @js_agent_api_base_url = app_data['js_agent_api_base_url']
-          end
-          if app_data.key?('js_agent_url')
-            @js_agent_url = app_data['js_agent_url']
-          end
-
-          @demomode = app_data.fetch('demomode', @demomode)
-        else
-          puts ' ********* ********* ********* *********'
-          puts '* tCell.io                               *'
-          puts '* Unsupported config file version        *'
-          puts ' ********* ********* ********* *********'
+          app_data = config['applications'][0]
+          @disable_all = to_bool(app_data.fetch('disable_all', @disable_all))
         end
-      rescue StandardError => e
-        puts ' ********* ********* ********* *********'
-        puts '* tCell.io                               *'
-        puts '* Could not load config file             *'
-        puts ' ********* ********* ********* *********'
-        puts e
+      rescue StandardError
+        # do nothing
       end
     end
 
     def to_bool(var)
-      return unless var
-      var.to_s.casecmp('true').zero? if %w[true false].include? var.to_s.downcase
-    end
-
-    def enforce_symbol_keys(hashmap)
-      hashmap.each_with_object({}) do |(k, v), memo|
-        memo[k.to_sym] = v
-      end
-    end
-
-    def logging_enabled?
-      @enabled && enforce_symbol_keys(@logging_options || {})[:enabled]
-    end
-
-    def log_filename
-      @agent_log_dir ||= File.join(@agent_home_dir, 'logs')
-      File.join(@agent_log_dir, @log_file_name)
-    end
-
-    def clean_logging_options
-      {
-        :enabled => true,
-        :level => 'INFO',
-        :filename => log_file_name
-      }.merge(enforce_symbol_keys(@logging_options || {}))
+      { 'true' => true, 'false' => false }[var.to_s.downcase]
+    end
+
+    def populate_configuration(native_agent_config_response)
+      # config
+      @enabled = native_agent_config_response['enabled']
+      @disabled_instrumentation = Set.new(native_agent_config_response['disabled_instrumentation'])
+      @fetch_policies_from_tcell = native_agent_config_response['update_policy']
+      @instrument = native_agent_config_response['instrument']
+
+      # app config
+      apps = native_agent_config_response['applications'] ? native_agent_config_response['applications']['first'] : {}
+      @app_id = apps['app_id']
+      @api_key = apps['api_key']
+      @hmac_key = apps['hmac_key']
+      @password_hmac_key = apps['password_hmac_key']
+
+      # proxy config
+      @reverse_proxy = apps['reverse_proxy']
+      @reverse_proxy_ip_address_header = apps['reverse_proxy_ip_address_header']
+
+      # endpoint config
+      endpoint = native_agent_config_response['endpoint_config'] || {}
+      @tcell_api_url = endpoint['api_url']
+
+      # ruby config
+      ruby_config = native_agent_config_response['ruby_config'] || {}
+      @enable_policy_polling = ruby_config['enable_policy_polling']
+      @enable_intercept_requests = !@disabled_instrumentation.include?('intercept_requests')
     end
   end
 

data/lib/tcell_agent/hooks/login_fraud.rb

@@ -3,7 +3,7 @@ require 'tcell_agent/agent'
 module TCellAgent
   module Hooks
     module LoginFraud
-      # Note: mock out in tests
+      # NOTE: mock out in tests
       def self.get_logger
         unless defined?(@login_fraud_logger)
           @login_fraud_logger = TCellAgent::ModuleLogger.new(TCellAgent.logger, name)

data/lib/tcell_agent/instrument_servers.rb

@@ -1,25 +1,21 @@
+# frozen_string_literal: true
+
 tcell_server = ENV['TCELL_AGENT_SERVER']
 
-if TCellAgent.configuration.should_instrument?
-  unless tcell_server && tcell_server == 'mock'
-    if (tcell_server && tcell_server == 'webrick') || defined?(Rails::Server)
-      require('tcell_agent/servers/rails_server')
+TCellAgent.thread_agent.instrument_built_ins if tcell_server &&
+                                                tcell_server == 'mock'
 
-    elsif (tcell_server && tcell_server == 'thin') || defined?(Thin)
-      require('tcell_agent/servers/thin')
+require('tcell_agent/servers/rails_server') if (tcell_server && tcell_server == 'webrick') ||
+                                               defined?(Rails::Server)
 
-    elsif (tcell_server && tcell_server == 'puma') || defined?(Puma)
-      require('tcell_agent/servers/puma')
+require('tcell_agent/servers/thin') if (tcell_server && tcell_server == 'thin') ||
+                                       defined?(Thin)
 
-    elsif (tcell_server && tcell_server == 'unicorn') || defined?(Unicorn)
-      require('tcell_agent/servers/unicorn')
+require('tcell_agent/servers/puma') if (tcell_server && tcell_server == 'puma') ||
+                                       defined?(Puma)
 
-    elsif (tcell_server && tcell_server == 'passenger') || defined?(PhusionPassenger)
-      require('tcell_agent/servers/passenger')
-    end
-  end
+require('tcell_agent/servers/unicorn') if (tcell_server && tcell_server == 'unicorn') ||
+                                          defined?(Unicorn)
 
-elsif (tcell_server && tcell_server == 'unicorn') || defined?(Unicorn)
-  # unicorn is always instrumented to support rolling restarts
-  require('tcell_agent/servers/unicorn')
-end
+require('tcell_agent/servers/passenger') if (tcell_server && tcell_server == 'passenger') ||
+                                            defined?(PhusionPassenger)

data/lib/tcell_agent/instrumentation/cmdi.rb

@@ -25,18 +25,18 @@ module TCellAgent
       cmd = ''
 
       TCellAgent::Instrumentation.safe_block('CMDI Parsing *args') do
-        unless args.empty?
-          args_copy = Array.new(args)
-          args_copy.shift if args_copy.first.is_a?(Hash)
-          args_copy.pop if args_copy.last.is_a?(Hash)
-
-          if args_copy.first.is_a?(Array)
-            cmd_n_argv0 = args_copy.shift
-            args_copy.unshift(cmd_n_argv0.first)
-          end
+        return cmd if args.nil? || args.empty?
+
+        args_copy = Array.new(args)
+        args_copy.shift if args_copy.first.is_a?(Hash)
+        args_copy.pop if args_copy.last.is_a?(Hash)
 
-          cmd = args_copy.join(' ')
+        if args_copy.first.is_a?(Array)
+          cmd_n_argv0 = args_copy.shift
+          args_copy.unshift(cmd_n_argv0.first)
         end
+
+        cmd = args_copy.join(' ')
       end
 
       cmd
@@ -46,15 +46,47 @@ module TCellAgent
       cmd = ''
 
       TCellAgent::Instrumentation.safe_block('CMDI Parsing *args') do
-        unless args.empty?
-          args_copy = Array.new(args)
-          first_arg = args_copy.shift
+        return cmd if args.nil? || args.empty?
 
-          cmd = first_arg[1..-1] if first_arg && first_arg[0] == '|'
-        end
+        args_copy = Array.new(args)
+        first_arg = args_copy.shift
+
+        cmd = first_arg[1..-1] if first_arg && (first_arg.is_a? String) && first_arg[0] == '|'
       end
 
       cmd
     end
+
+    def self.raise_if_block(cmd)
+      return unless TCellAgent::Cmdi.block_command?(cmd)
+
+      raise "tCell.io Agent: Command not allowed by policy: #{cmd}"
+    end
+
+    def self.default_cmdi_handler(args)
+      cmd = TCellAgent::Cmdi.parse_command(*args)
+
+      raise_if_block(cmd)
+    end
+
+    def self.popen_cmdi_handler(args)
+      return if args.empty?
+
+      cmd = ''
+
+      TCellAgent::Instrumentation.safe_block('CMDI Parsing popen *args') do
+        args_copy = Array.new(args)
+        args_copy.shift if args_copy.first.is_a?(Hash)
+        args_copy.pop if args_copy.last.is_a?(Hash)
+
+        cmd = if args_copy.first.is_a?(String)
+                args_copy.shift
+              else
+                TCellAgent::Cmdi.parse_command(*args_copy.shift)
+              end
+      end
+
+      raise_if_block(cmd)
+    end
   end
 end

data/lib/tcell_agent/instrumentation/lfi.rb

@@ -5,6 +5,8 @@ require 'tcell_agent/configuration'
 module TCellAgent
   module Instrumentation
     module Lfi
+      extend TCellAgent::ModuleLoggerAccess
+
       def self.block_file_access?(path, mode)
         TCellAgent::Instrumentation.safe_block('Checking Local Files Policy') do
           if TCellAgent::Utils::Strings.present?(path)
@@ -26,18 +28,26 @@ module TCellAgent
         path = ''
         mode = ''
 
-        return ['', ''] if args.empty?
-
         TCellAgent::Instrumentation.safe_block('LFI Parsing *args') do
+          return ['', ''] if args.nil? || args.empty?
+
           args_copy = Array.new(args)
           path = args_copy.shift
           mode = args_copy.shift || 'r'
-        end
 
-        if path && path.to_s[0] != '|'
-          [File.expand_path(path).to_s, convert_mode(mode)]
-        else
-          ['', '']
+          if path && path.to_s[0] != '|'
+            path = File.expand_path(path.to_s)
+
+            mode = if mode && mode.is_a?(Hash)
+                     convert_mode(mode[:mode])
+                   else
+                     convert_mode(mode)
+                   end
+
+            [path, mode]
+          else
+            ['', '']
+          end
         end
       end
 
@@ -46,16 +56,29 @@ module TCellAgent
         mode = 'Read'
 
         TCellAgent::Instrumentation.safe_block('LFI Parsing ARGF') do
-          if ARGF.eof? && !ARGV.empty?
-            argv_copy = Array.new(ARGV)
-            path = argv_copy.shift
-          else
-            path = ARGF.filename
+          begin
+            return ['', ''] if ARGF.file == $stdin
+
+            if ARGF.eof? && !ARGV.empty?
+              argv_copy = Array.new(ARGV)
+              path = argv_copy.shift
+            else
+              path = ARGF.filename
+            end
+
+            if path && path.to_s[0] != '|'
+              [File.expand_path(path.to_s), mode]
+            else
+              ['', '']
+            end
+          rescue Errno::ENOENT
+            module_logger.debug('LFI Parsing ARGF: attempted to read a non-existent file')
+            ['', '']
+          rescue Errno::EISDIR
+            module_logger.debug('LFI Parsing ARGF: attempted to read a directory')
+            [ARGF.filename, mode]
           end
         end
-
-        path = File.expand_path(path) unless path.nil?
-        [path.to_s, mode]
       end
 
       def self.convert_mode(mode)
@@ -68,6 +91,40 @@ module TCellAgent
         end
         'Read'
       end
+
+      def self.raise_if_block(path, mode)
+        return unless block_file_access?(path, mode)
+
+        raise IOError, "tCell.io Agent: Attempted access to file #{path} with mode #{mode} denied"
+      end
+
+      def self.default_open_handler(args, override_mode = '')
+        path, mode = extract_path_mode(*args)
+
+        mode = override_mode unless override_mode.empty?
+
+        raise_if_block(path, mode)
+      end
+
+      def self.argf_open_handler
+        path, mode = TCellAgent::Instrumentation::Lfi.extract_path_mode_argf
+
+        raise_if_block(path, mode)
+      end
+
+      def self.cmdi_open_handler(args, override_mode = '')
+        path, mode = extract_path_mode(*args)
+
+        mode = override_mode unless override_mode.empty?
+
+        raise_if_block(path, mode)
+
+        return unless path.empty?
+
+        cmd = TCellAgent::Cmdi.parse_command_from_open(*args)
+
+        TCellAgent::Cmdi.raise_if_block(cmd) if cmd
+      end
     end
   end
 end

data/lib/tcell_agent/instrumentation/monkey_patches/ruby_2/file.rb

@@ -0,0 +1,21 @@
+class File
+  class << self
+    if TCellAgent.configuration.should_instrument?('File::new')
+      alias_method :tcell_original_new, :new
+      def new(*args, &block)
+        TCellAgent::Instrumentation::Lfi.default_open_handler(args)
+
+        tcell_original_new(*args, &block)
+      end
+    end
+
+    if TCellAgent.configuration.should_instrument?('File::open')
+      alias_method :tcell_original_open, :open
+      def open(*args, &block)
+        TCellAgent::Instrumentation::Lfi.default_open_handler(args)
+
+        tcell_original_open(*args, &block)
+      end
+    end
+  end
+end