tcell_agent 2.3.0 → 2.5.1

data/lib/tcell_agent/instrumentation.rb

@@ -65,7 +65,8 @@ module TCellAgent
                     :password, :route_id, :path, :uri, :fullpath, :context_filters_by_term,
                     :database_filters, :remote_address, :user_agent, :request_method,
                     :path_parameters, :patches_blocking_triggered, :grape_mount_endpoint,
-                    :referrer, :csrf_exception_name, :sql_exceptions, :database_result_sizes
+                    :referrer, :csrf_exception_name, :sql_exceptions, :database_result_sizes,
+                    :reverse_proxy_header_value
 
       def self.filterx(sanitize_string, event_flag, replace_flag, term)
         send_event = false
@@ -91,26 +92,31 @@ module TCellAgent
 
       def valid_term?(term)
         return true if !term.nil? && term != '' && term.to_s.length >= 5
+
         false
       end
 
       def add_response_db_filter(term, action_obj, database, schema, table, field)
         return unless valid_term?(term)
+
         context_filters_by_term[term.to_s].add(ContextFilter.new.for_database(database, schema, table, field, action_obj))
       end
 
       def add_filter_for_request_parameter(term, rule, parameter_name)
         return unless valid_term?(term)
+
         context_filters_by_term[term.to_s].add(ContextFilter.new.for_request('form', parameter_name, rule))
       end
 
       def add_filter_for_header_value(term, rule, header_name)
         return unless valid_term?(term)
+
         context_filters_by_term[term.to_s].add(ContextFilter.new.for_request('header', header_name, rule))
       end
 
       def add_filter_for_cookie_value(term, rule, cookie_name)
         return unless valid_term?(term)
+
         context_filters_by_term[term.to_s].add(ContextFilter.new.for_request('cookie', cookie_name, rule))
       end
 
@@ -139,6 +145,7 @@ module TCellAgent
           send_flag = TCellData.filterx(body, !event_filters.empty?, !replace_filters.empty?, term)
           send_flag ||= TCellData.filterx(body, !event_filters.empty?, !replace_filters.empty?, CGI.escapeHTML(term))
           next unless send_flag
+
           (replace_filters + event_filters).each do |filter|
             base_event = TCellAgent::SensorEvents::DlpEvent.new(
               route_id,
@@ -183,6 +190,7 @@ module TCellAgent
           event_filters = (context_filters.select { |context_filter| (context_filter.rule.log_redact != true && context_filter.rule.log_event == true) })
           send_flag = TCellData.filterx(log_msg, !event_filters.empty?, !replace_filters.empty?, term)
           next unless send_flag
+
           (replace_filters + event_filters).each do |filter|
             base_event = TCellAgent::SensorEvents::DlpEvent.new(
               route_id,
@@ -213,7 +221,7 @@ module TCellAgent
       end
     end
 
-    # Note: mock for tests
+    # NOTE: mock for tests
     def self.get_safe_block_logger
       unless defined?(@safe_block_logger)
         @safe_block_logger = TCellAgent::ModuleLogger.new(TCellAgent.logger, name)
@@ -224,15 +232,15 @@ module TCellAgent
 
     def self.safe_block(message, &block)
       block.call
-    rescue StandardError => ex
+    rescue StandardError => e
       logger = get_safe_block_logger
-      logger.error("Error #{message} (#{ex.class}): #{ex.message}")
-      logger.exception(ex)
+      logger.error("Error #{message} (#{e.class}): #{e.message}")
+      logger.exception(e)
     end
 
     def self.safe_block_no_log(_message, &block)
       block.call
-    rescue StandardError # rubocop:disable Lint/HandleExceptions
+    rescue StandardError
       # do nothing
     end
   end

data/lib/tcell_agent/logger.rb

@@ -31,13 +31,13 @@ module TCellAgent
     end
   end
 
-  # Note: since the agent waits until native agent
+  # NOTE: since the agent waits until native agent
   # is available, this is only used in errors
   # throwned while the agent is instrumenting or starting up
   # so it's ok to send those to STDOUT always
   class RubyLogger
     def initialize
-      @logger = Logger.new(STDOUT)
+      @logger = Logger.new(STDOUT) # rubocop:disable Style/GlobalStdStream
     end
 
     def exception(module_name, exception)

data/lib/tcell_agent/policies/dataloss_policy.rb

@@ -110,24 +110,22 @@ module TCellAgent
 
       def get_actions_for_request(context, variable, route_id = nil)
         return nil if context.nil? || variable.nil?
+
         route_id = '*' if route_id.nil?
         if context != RequestProtectionManager::COOKIE
           variable = variable.downcase
         end
         actions = Set.new
         if @request_filter_actions.key?(context)
-          if @request_filter_actions[context].key?(route_id)
-            if @request_filter_actions[context][route_id].key?(variable)
-              actions.merge(@request_filter_actions[context][route_id][variable])
-            end
+          if @request_filter_actions[context].key?(route_id) && @request_filter_actions[context][route_id].key?(variable)
+            actions.merge(@request_filter_actions[context][route_id][variable])
           end
-          if route_id != '*' && @request_filter_actions[context].key?('*')
-            if @request_filter_actions[context]['*'].key?(variable)
-              actions.merge(@request_filter_actions[context]['*'][variable])
-            end
+          if route_id != '*' && @request_filter_actions[context].key?('*') && @request_filter_actions[context]['*'].key?(variable)
+            actions.merge(@request_filter_actions[context]['*'][variable])
           end
         end
         return nil if actions.size <= 0
+
         actions
       end
 
@@ -136,12 +134,16 @@ module TCellAgent
         actions = Set.new
         [database, '*'].each do |d|
           next if @database_actions.key?(d) == false
+
           [schema, '*'].each do |s|
             next if @database_actions[d].key?(s) == false
+
             [table, '*'].each do |t|
               next if @database_actions[d][s].key?(t) == false
+
               [field, '*'].each do |f|
                 next if @database_actions[d][s][t].key?(f) == false
+
                 route_id_rules = @database_actions[d][s][t][f]
                 if route_id_rules.key?(route_id)
                   actions.merge(@database_actions[d][s][t][f][route_id])
@@ -154,6 +156,7 @@ module TCellAgent
           end
         end
         return nil if actions.empty?
+
         actions
       end
 
@@ -240,8 +243,10 @@ module TCellAgent
             end
 
             next unless context && @request_filter_actions.key?(context) && variables && options
+
             filter_actions = DataLossPolicy.actions_from_json(options)
             next if filter_actions.nil?
+
             @enabled = true
             filter_actions.action_id = rule_id
             variables.each do |variable|
@@ -258,8 +263,10 @@ module TCellAgent
         end
 
         return unless data_json.key?('db_protections')
+
         protections = data_json['db_protections']
         return unless protections
+
         protections.each do |protection_json|
           scope = protection_json.fetch('scope', nil)
           databases = protection_json.fetch('databases', ['*'])

data/lib/tcell_agent/policies/headers_policy.rb

@@ -14,10 +14,10 @@ module TCellAgent
         @enabled = enablements['headers'] || false
       end
 
-      def get_headers(tcell_context)
+      def get_headers(content_type, tcell_context)
         return [] unless @enabled
 
-        response = @native_agent.get_headers(tcell_context)
+        response = @native_agent.get_headers(content_type, tcell_context)
         response['headers'] || []
       end
     end

data/lib/tcell_agent/policies/patches_policy.rb

@@ -17,10 +17,14 @@ module TCellAgent
       def block_request?(appsensor_meta)
         return false unless @enabled
 
-        response = @native_agent.apply_patches(
-          appsensor_meta
-        )
-        !response['apply_response'].nil? && response['apply_response']['status'] == 'Blocked'
+        quick_check_response = @native_agent.apply_suspicious_quick_check(appsensor_meta)
+
+        if quick_check_response == 1
+          response = @native_agent.apply_patches(appsensor_meta)
+          return !response['apply_response'].nil? && response['apply_response']['status'] == 'Blocked'
+        end
+
+        quick_check_response == 2
       end
     end
   end

data/lib/tcell_agent/policies/policies_manager.rb

@@ -47,6 +47,7 @@ module TCellAgent
       TCellAgent::Instrumentation.safe_block('Setting DLP policy') do
         dlp_api_identifier = TCellAgent::Policies::DataLossPolicy.api_identifier
         return unless policies_json.key?(dlp_api_identifier)
+
         @policies[dlp_api_identifier] = TCellAgent::Policies::DataLossPolicy.new(
           policies_json[dlp_api_identifier]
         )

data/lib/tcell_agent/policies/policy_polling.rb

@@ -20,6 +20,7 @@ module TCellAgent
 
       @policy_polling_worker_mutex.synchronize do
         return if policy_polling_running?
+
         start_policy_polling_loop(native_agent)
       end
     end
@@ -44,9 +45,9 @@ module TCellAgent
               policies_and_enablements['enablements'],
               policies_and_enablements['policies']
             )
-          rescue StandardError => standard_error
-            module_logger.error("Error in polling policies: #{standard_error.message}")
-            module_logger.exception(standard_error)
+          rescue StandardError => e
+            module_logger.error("Error in polling policies: #{e.message}")
+            module_logger.exception(e)
           end
 
           # TODO(ralba): this might need to be changed to see how it affects performance

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

@@ -14,6 +14,7 @@ module TCellAgent
           tcell_data = request.env[TCellAgent::Instrumentation::TCELL_ID]
 
           return unless tcell_data
+
           headers = request.env
 
           if result.is_a?(Doorkeeper::OAuth::TokenResponse)

data/lib/tcell_agent/rails/better_ip.rb

@@ -4,28 +4,16 @@ require 'tcell_agent/instrumentation'
 module TCellAgent
   module Utils
     module Rails
-      def self.better_ip(request)
-        if TCellAgent.configuration.reverse_proxy
-          TCellAgent::Instrumentation.safe_block('Extracting reverse proxy IP') do
-            reverse_proxy_header = TCellAgent.configuration.reverse_proxy_ip_address_header
-            reverse_proxy_header = if TCellAgent::Utils::Strings.present?(reverse_proxy_header)
-                                     'HTTP_' + reverse_proxy_header.upcase.tr('-', '_')
-                                   else
-                                     'HTTP_X_FORWARDED_FOR'
-                                   end
+      def self.reverse_proxy_header(request)
+        return unless TCellAgent.configuration.reverse_proxy
 
-            x_forwarded_for = request.env[reverse_proxy_header]
-            ip = if TCellAgent::Utils::Strings.present?(x_forwarded_for)
-                   x_forwarded_for.split(',')[0].strip
-                 else
-                   request.ip
-                 end
+        TCellAgent::Instrumentation.safe_block('Extracting reverse proxy header') do
+          reverse_proxy_header = TCellAgent.configuration.reverse_proxy_ip_address_header
 
-            return ip
-          end
-        end
+          return if reverse_proxy_header.nil? || reverse_proxy_header.empty?
 
-        request.ip
+          return request.env["HTTP_#{reverse_proxy_header.upcase.tr('-', '_')}"]
+        end
       end
     end
   end

data/lib/tcell_agent/rails/dlp/process_request.rb

@@ -37,6 +37,7 @@ module TCellAgent
       dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DATALOSS)
       tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
       return unless tcell_context && dataex_policy && dataex_policy.actions_for_form_parameter?
+
       for_params(request) do |_method, param_name, param_value|
         actions = dataex_policy.get_actions_for_form_parameter(param_name, tcell_context.route_id)
         if actions
@@ -51,11 +52,13 @@ module TCellAgent
       dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DATALOSS)
       tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
       return unless tcell_context && dataex_policy && dataex_policy.actions_for_headers?
+
       headers = request.env.select { |k, _v| k.start_with? 'HTTP_' }
       headers.each do |header_name, header_value|
         header_name = header_name.sub(/^HTTP_/, '').tr('_', '-')
         actions = dataex_policy.get_actions_for_header(header_name)
         next unless actions
+
         actions.each do |action|
           tcell_context.add_filter_for_header_value(header_value, action, header_name)
         end
@@ -66,9 +69,11 @@ module TCellAgent
       dataex_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DATALOSS)
       tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
       return unless tcell_context && dataex_policy && dataex_policy.actions_for_cookie?
+
       request.cookies.each do |cookie_name, cookie_value|
         actions = dataex_policy.get_actions_for_cookie(cookie_name)
         next unless actions
+
         actions.each do |action|
           tcell_context.add_filter_for_cookie_value(cookie_value, action, cookie_name)
         end

data/lib/tcell_agent/rails/dlp.rb

@@ -80,6 +80,7 @@ module TCellAgent
               normalized_column_names[namespaced_column_name] = column_name
 
               next unless column_name && (!namespace || namespace == table_name)
+
               rules = dlp_policy.get_actions_for_table(
                 database_name,
                 '*',
@@ -190,6 +191,7 @@ module TCellAgent
             results[0...TCellAgent.configuration.max_data_ex_db_records_per_request].each do |record|
               column_name_to_rules.each do |column_name, rules|
                 next unless rules
+
                 rules.each do |rule|
                   tcell_context.add_response_db_filter(
                     record[column_name.to_sym],
@@ -301,31 +303,29 @@ module TCellAgent
       def log_enforce(tcell_context, sanitize_string)
         if TCellAgent.configuration.should_instrument? &&
            TCellAgent.configuration.should_intercept_requests?
-          if tcell_context && tcell_context.session_id
-            session_id_actions = get_actions_for_session_id
-            if session_id_actions
-              send_event = false
-              sanitize_string.gsub!(tcell_context.session_id) do |m|
-                if session_id_actions.log_redact
-                  send_event = true
-                  m = '[session_id]'
-                elsif session_id_actions.log_hash
-                  send_event = true
-                  m = '[hash]'
-                elsif session_id_actions.log_event
-                  send_event = true
-                end
-                m
-              end
-              if send_event
-                TCellAgent.send_event(
-                  TCellAgent::SensorEvents::DlpEvent.new(
-                    tcell_context.route_id,
-                    tcell_context.uri,
-                    TCellAgent::SensorEvents::DlpEvent::FOUND_IN_LOG
-                  ).for_framework(TCellAgent::SensorEvents::DlpEvent::FRAMEWORK_VARIABLE_SESSION_ID)
-                )
+          session_id_actions = get_actions_for_session_id
+          if tcell_context && tcell_context.session_id && session_id_actions
+            send_event = false
+            sanitize_string.gsub!(tcell_context.session_id) do |m|
+              if session_id_actions.log_redact
+                send_event = true
+                m = '[session_id]'
+              elsif session_id_actions.log_hash
+                send_event = true
+                m = '[hash]'
+              elsif session_id_actions.log_event
+                send_event = true
               end
+              m
+            end
+            if send_event
+              TCellAgent.send_event(
+                TCellAgent::SensorEvents::DlpEvent.new(
+                  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
@@ -336,32 +336,32 @@ module TCellAgent
       def response_body_enforce(tcell_context, sanitize_string)
         if TCellAgent.configuration.should_instrument? &&
            TCellAgent.configuration.should_intercept_requests?
-          if tcell_context && tcell_context.session_id
-            session_id_actions = get_actions_for_session_id
-            if session_id_actions
-              send_event = false
-              sanitize_string.gsub!(tcell_context.session_id) do |m|
-                if session_id_actions.body_redact
-                  # m = "[session_id]"
-                  send_event = true
-                elsif session_id_actions.body_hash
-                  # m = "[hash]"
-                  send_event = true
-                elsif session_id_actions.body_event
-                  send_event = true
-                end
-                m
+          session_id_actions = get_actions_for_session_id
+          if tcell_context && tcell_context.session_id && session_id_actions
+            send_event = false
+            sanitize_string.gsub!(tcell_context.session_id) do |m|
+              # rubocop:disable Lint/DuplicateBranch
+              if session_id_actions.body_redact
+                # m = "[session_id]"
+                send_event = true
+              elsif session_id_actions.body_hash
+                # m = "[hash]"
+                send_event = true
+              elsif session_id_actions.body_event
+                send_event = true
               end
+              # rubocop:enable Lint/DuplicateBranch
+              m
             end
-            if send_event
-              TCellAgent.send_event(
-                TCellAgent::SensorEvents::DlpEvent.new(
-                  tcell_context.route_id,
-                  tcell_context.uri,
-                  TCellAgent::SensorEvents::DlpEvent::FOUND_IN_BODY
-                ).for_framework(TCellAgent::SensorEvents::DlpEvent::FRAMEWORK_VARIABLE_SESSION_ID)
-              )
-            end
+          end
+          if send_event
+            TCellAgent.send_event(
+              TCellAgent::SensorEvents::DlpEvent.new(
+                tcell_context.route_id,
+                tcell_context.uri,
+                TCellAgent::SensorEvents::DlpEvent::FOUND_IN_BODY
+              ).for_framework(TCellAgent::SensorEvents::DlpEvent::FRAMEWORK_VARIABLE_SESSION_ID)
+            )
           end
         end
 

data/lib/tcell_agent/rails/dlp_handler.rb

@@ -39,19 +39,18 @@ module TCellAgent
 
           TCellAgent::Instrumentation.safe_block('DLP Handler get handler and context') do
             if TCellAgent.configuration.should_instrument? &&
-               TCellAgent.configuration.should_intercept_requests?
+               TCellAgent.configuration.should_intercept_requests? &&
+               TCellAgent::Utils::Rails.processable_response?(response_headers)
 
               # do all this work so that dlp doesn't run at all unless it's on and there
               # are rules to run
-              if TCellAgent::Utils::Rails.processable_response?(response_headers)
-                dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DATALOSS)
-                if dlp_policy && dlp_policy.get_actions_for_session_id
-                  tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
-                  if tcell_context && tcell_context.session_id
-                    dlp_handler = proc { |tc, resp|
-                      handle_dlp!(tc, resp)
-                    }
-                  end
+              dlp_policy = TCellAgent.policy(TCellAgent::PolicyTypes::DATALOSS)
+              if dlp_policy && dlp_policy.get_actions_for_session_id
+                tcell_context = request.env[TCellAgent::Instrumentation::TCELL_ID]
+                if tcell_context && tcell_context.session_id
+                  dlp_handler = proc { |tc, resp|
+                    handle_dlp!(tc, resp)
+                  }
                 end
               end
             end

data/lib/tcell_agent/rails/js_agent_insert.rb

@@ -4,8 +4,7 @@ module TCellAgent
   module Instrumentation
     module Rails
       module JSAgent
-        HEAD_SEARCH_REGEX = /<head>/
-
+        HEAD_SEARCH_REGEX = Regexp.new('(<head>|<head( |\n).*?>)', Regexp::IGNORECASE)
         def self.insert_now(js_agent_handler, script_insert, rack_body, content_length)
           TCellAgent::Instrumentation.safe_block('Handling JSAgent Insert Now') do
             if js_agent_handler
@@ -32,7 +31,7 @@ module TCellAgent
           TCellAgent::Instrumentation.safe_block('Handling JSAgent insert') do
             new_response = response.sub(
               TCellAgent::Instrumentation::Rails::JSAgent::HEAD_SEARCH_REGEX,
-              "<head>#{script_insert}"
+              "\\1#{script_insert}"
             )
           end
 

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

@@ -26,7 +26,8 @@ module TCellAgent
                 env[TCellAgent::Instrumentation::TCELL_ID].path = request.path
                 env[TCellAgent::Instrumentation::TCELL_ID].user_agent = request.user_agent
                 env[TCellAgent::Instrumentation::TCELL_ID].referrer = request.referrer
-                env[TCellAgent::Instrumentation::TCELL_ID].remote_address = TCellAgent::Utils::Rails.better_ip(request)
+                env[TCellAgent::Instrumentation::TCELL_ID].remote_address = request.ip
+                env[TCellAgent::Instrumentation::TCELL_ID].reverse_proxy_header_value = TCellAgent::Utils::Rails.reverse_proxy_header(request)
                 if request.request_method
                   env[TCellAgent::Instrumentation::TCELL_ID].request_method = request.request_method
                 end

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

@@ -25,8 +25,6 @@ module TCellAgent
             if TCellAgent.configuration.should_intercept_requests?
               request = Rack::Request.new(env)
 
-              request['init'] = true
-
               TCellAgent::Instrumentation.safe_block('Setting session_id & user_id') do
                 if request.session
                   env[TCellAgent::Instrumentation::TCELL_ID].session_id =
@@ -44,9 +42,7 @@ module TCellAgent
               end
             end
 
-            response = @app.call(env)
-
-            response
+            @app.call(env)
           end
         end
       end

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

@@ -39,6 +39,7 @@ module TCellAgent
             TCellAgent::Instrumentation.safe_block('Handling headers') do
               headers_policy = TCellAgent.policy(TCellAgent::PolicyTypes::HEADERS)
               policy_headers = headers_policy.get_headers(
+                headers['Content-Type'],
                 request.env[TCellAgent::Instrumentation::TCELL_ID]
               )
               policy_headers.each do |header_info|

data/lib/tcell_agent/rails/routes/grape.rb

@@ -7,8 +7,9 @@ module TCellAgent
         begin
           return route.app < Grape::API if ::Rails::VERSION::MAJOR == 4 &&
                                            ::Rails::VERSION::MINOR < 2
+
           return route.app.app < Grape::API
-        rescue StandardError # rubocop:disable Lint/HandleExceptions
+        rescue StandardError
           # do nothing
         end
       end

data/lib/tcell_agent/rails/settings_reporter.rb

@@ -6,12 +6,9 @@ require 'tcell_agent/sensor_events/server_agent'
 module TCellAgent
   module Instrumentation
     module Rails
-      def self.send_framework_info
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::ServerAgentAppFrameworkEvent.new(
-            'Rails', ::Rails.version
-          )
-        )
+      def self.framework_details
+        { 'app_framework' => 'Rails',
+          'app_framework_version' => ::Rails.version }
       end
 
       def self.send_settings

data/lib/tcell_agent/rails/tcell_body_proxy.rb

@@ -53,18 +53,16 @@ module TCellAgent
           @body.respond_to?(method_name, include_all)
         end
 
-        def method_missing(method_name, *args, &block) # rubocop:disable Style/MethodMissing
+        def method_missing(method_name, *args, &block)
           @body.__send__(method_name, *args, &block)
         end
 
         def process_body(body)
           TCellAgent::Instrumentation.safe_block('Processing tcell body proxy body') do
             chunked_response_match = nil
-            if body.class.name == 'String'
-              if body =~ /^([[:xdigit:]]+)(;.+)?\r\n/
-                chunked_response_match = Regexp.last_match(1)
-                @content_length += chunked_response_match.to_i(16)
-              end
+            if body.class.name == 'String' && body =~ /^([[:xdigit:]]+)(;.+)?\r\n/
+              chunked_response_match = Regexp.last_match(1)
+              @content_length += chunked_response_match.to_i(16)
             end
 
             new_body = body

data/lib/tcell_agent/routes/table.rb

@@ -2,6 +2,7 @@ module TCellAgent
   module Routes
     class FieldEndpoint
       attr_accessor :discovered
+
       def initialize
         super()
         @discovered = false
@@ -11,6 +12,7 @@ module TCellAgent
     class RouteEndpoint
       attr_accessor :database
       attr_accessor :database_queries_discovered
+
       def initialize
         @database_queries_discovered = {}
         @database = Hash.new do |d_h, d_k| # Database
@@ -27,6 +29,7 @@ module TCellAgent
 
     class RouteTable
       attr_accessor :routes
+
       def initialize
         @routes = Hash.new { |h, k| h[k] = RouteEndpoint.new }
       end

data/lib/tcell_agent/rust/agent_config.rb

@@ -21,6 +21,21 @@ module TCellAgent
           self['overrides'] = { 'applications' => [{ :enable_json_body_inspection => true }],
                                 'config_file_path' => configuration.get_config_file_path }
         end
+
+        set_agent_details
+      end
+
+      def set_agent_details
+        framework_details = if defined?(Rails)
+                              TCellAgent::Instrumentation::Rails.framework_details
+                            else
+                              {}
+                            end
+
+        self['agent_details'] = { 'language' => 'Ruby',
+                                  'language_version' => RUBY_VERSION,
+                                  'app_framework' => framework_details['app_framework'],
+                                  'app_framework_version' => framework_details['app_framework_version'] }
       end
     end
 
@@ -53,6 +68,9 @@ module TCellAgent
         self['log_enabled'] = configuration.logging_options[:enabled]
         self['log_filename'] = configuration.logging_options[:log_filename]
         self['log_level'] = configuration.logging_options[:level]
+        self['proxy_url'] = configuration.proxy_url
+        self['proxy_username'] = configuration.proxy_username
+        self['proxy_password'] = configuration.proxy_password
         self['update_policy'] = configuration.fetch_policies_from_tcell
       end
     end