tcell_agent 1.1.3 → 1.1.4

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

@@ -1,29 +1,24 @@
 module TCellAgent
   module Instrumentation
     module RouteId
-
       def self.update_context(env, parameters, route)
         tcell_context = env[TCellAgent::Instrumentation::TCELL_ID]
 
-        if route && tcell_context
-          tcell_context.path_parameters = parameters
+        return unless route && tcell_context
 
-          route_path = route.path.spec.to_s
+        tcell_context.path_parameters = parameters
+        route_path = route.path.spec.to_s
+        grape_mount_endpoint = nil
 
-          grape_mount_endpoint = nil
-          if TCellAgent::Instrumentation::grape_route?(route)
-            grape_mount_endpoint = route_path
-          end
+        grape_mount_endpoint = route_path if TCellAgent::Instrumentation.grape_route?(route)
 
-          if grape_mount_endpoint
-            tcell_context.grape_mount_endpoint = grape_mount_endpoint
+        if grape_mount_endpoint
+          tcell_context.grape_mount_endpoint = grape_mount_endpoint
 
-          else
-            tcell_context.route_id = TCellAgent::SensorEvents::Util.calculateRouteId(tcell_context.request_method, route_path)
-          end
+        else
+          tcell_context.route_id = TCellAgent::SensorEvents::Util.calculate_route_id(tcell_context.request_method, route_path)
         end
       end
-
     end
   end
 end

data/lib/tcell_agent/rails/settings_reporter.rb

@@ -8,43 +8,54 @@ module TCellAgent
   module Instrumentation
     module Rails
       def self.send_framework_info
-        if (TCellAgent.configuration.exp_config_settings)
-          version = ::Rails.version
-          TCellAgent.send_event(TCellAgent::SensorEvents::ServerAgentAppFrameworkEvent.new(
-                      "Rails", version
-                    ))
-        end
+        return unless TCellAgent.configuration.exp_config_settings
+
+        TCellAgent.send_event(
+          TCellAgent::SensorEvents::ServerAgentAppFrameworkEvent.new(
+            'Rails', ::Rails.version
+          )
+        )
       end
+
       def self.send_language_info
-        if (TCellAgent.configuration.exp_config_settings)
-          language = TCellAgent::SystemInfo.get_language
-          language_version = TCellAgent::SystemInfo.get_language_version
-          TCellAgent.send_event(TCellAgent::SensorEvents::ServerAgentDetailsLanguageEvent.new(
-                      language, language_version
-                    ))          
-        end
+        return unless TCellAgent.configuration.exp_config_settings
+
+        language = TCellAgent::SystemInfo.get_language
+        language_version = TCellAgent::SystemInfo.get_language_version
+        TCellAgent.send_event(
+          TCellAgent::SensorEvents::ServerAgentDetailsLanguageEvent.new(
+            language, language_version
+          )
+        )
       end
+
       def self.send_settings(application)
-        if (TCellAgent.configuration.exp_config_settings)
-          # Defaults to true
-          csrf_protection = application.config.action_controller.allow_forgery_protection || true
-          TCellAgent.send_event(TCellAgent::SensorEvents::AppConfigSettingEvent.new(
-                      "Rails", "core", "", "csrf_protection", csrf_protection
-                    ))
-
-          # Defaults to false if nil
-          mass_assignment_allowed = application.config.action_controller.permit_all_parameters || false
-          TCellAgent.send_event(TCellAgent::SensorEvents::AppConfigSettingEvent.new(
-                      "Rails", "core", "", "mass_assignment_allowed", mass_assignment_allowed
-                    ))
-
-          # Defaults to never
-          session_expire = application.config.session_options[:expire_after] || -1
-          TCellAgent.send_event(TCellAgent::SensorEvents::AppConfigSettingEvent.new(
-                      "Rails", "session", "", "timeout", session_expire
-                    ))
-        end
+        return unless TCellAgent.configuration.exp_config_settings
+
+        # Defaults to true
+        csrf_protection = application.config.action_controller.allow_forgery_protection || true
+        TCellAgent.send_event(
+          TCellAgent::SensorEvents::AppConfigSettingEvent.new(
+            'Rails', 'core', '', 'csrf_protection', csrf_protection
+          )
+        )
+
+        # Defaults to false if nil
+        mass_assignment_allowed = application.config.action_controller.permit_all_parameters || false
+        TCellAgent.send_event(
+          TCellAgent::SensorEvents::AppConfigSettingEvent.new(
+            'Rails', 'core', '', 'mass_assignment_allowed', mass_assignment_allowed
+          )
+        )
+
+        # Defaults to never
+        session_expire = application.config.session_options[:expire_after] || -1
+        TCellAgent.send_event(
+          TCellAgent::SensorEvents::AppConfigSettingEvent.new(
+            'Rails', 'session', '', 'timeout', session_expire
+          )
+        )
       end
     end
   end
-end
+end

data/lib/tcell_agent/rails/tcell_body_proxy.rb

@@ -3,10 +3,8 @@ require 'tcell_agent/instrumentation'
 module TCellAgent
   module Instrumentation
     module Rails
-
       class TCellBodyProxy
-
-        attr_accessor :appsensor_meta
+        attr_accessor :appsensor_meta_event
 
         # for specs
         attr_accessor :content_length
@@ -30,47 +28,47 @@ module TCellAgent
         end
 
         def close
-          TCellAgent::Instrumentation.safe_block("Running AppSensor deferred due to streaming") do
-            if @appsensor_meta
-              @appsensor_meta.response_content_bytes_len = @content_length
-              TCellAgent.send_event(@appsensor_meta)
+          TCellAgent::Instrumentation.safe_block('Running AppSensor deferred due to streaming') do
+            if @appsensor_meta_event
+              @appsensor_meta_event.meta_data.response_content_bytes_len = @content_length
+              TCellAgent.send_event(@appsensor_meta_event)
             end
           end
 
           @body.close if @body.respond_to?(:close)
         end
 
-        def each(&block)
+        def each
           return to_enum(:each) unless block_given?
 
-          @body.each { |body_chunk|
+          @body.each do |body_chunk|
             body_chunk = process_body(body_chunk)
 
             yield body_chunk
-          }
+          end
         end
 
-        def respond_to?(method_name, include_all=false)
+        def respond_to?(method_name, include_all = false)
           @body.respond_to?(method_name, include_all)
         end
 
-        def method_missing(method_name, *args, &block)
+        def method_missing(method_name, *args, &block) # rubocop:disable Style/MethodMissing
           @body.__send__(method_name, *args, &block)
         end
 
         def process_body(body)
-          TCellAgent::Instrumentation.safe_block("Processing tcell body proxy body") do
+          TCellAgent::Instrumentation.safe_block('Processing tcell body proxy body') do
             chunked_response_match = nil
-            if body.class.name == "String"
+            if body.class.name == 'String'
               if body =~ /^([[:xdigit:]]+)(;.+)?\r\n/
-                chunked_response_match = $1
+                chunked_response_match = Regexp.last_match(1)
                 @content_length += chunked_response_match.to_i(16)
               end
             end
 
             new_body = body
-            if body.class.name == "ActionView::OutputBuffer" ||
-                (body.class.name == "String" && !chunked_response_match)
+            if body.class.name == 'ActionView::OutputBuffer' ||
+               (body.class.name == 'String' && !chunked_response_match)
               if @process_js_and_dlp
                 if @js_agent_insertion_proc
                   new_body = @js_agent_insertion_proc.call(@script_insert, body)
@@ -92,7 +90,6 @@ module TCellAgent
           end
         end
       end
-
     end
   end
 end

data/lib/tcell_agent/routes/table.rb

@@ -1,37 +1,35 @@
 module TCellAgent
   module Routes
-  	class FieldEndpoint
-	    attr_accessor :discovered
-	    def initialize
-	    	super()
-	    	@discovered = false
-	    end
-  	end
+    class FieldEndpoint
+      attr_accessor :discovered
+      def initialize
+        super()
+        @discovered = false
+      end
+    end
 
-  	class RouteEndpoint
-	    attr_accessor :database
-        attr_accessor :database_queries_discovered
-	    def initialize
-            @database_queries_discovered = {}
-	    	@database = Hash.new {|h,k| # Database
-							h[k] = Hash.new {|h,k| # Schema
-								h[k] = Hash.new {|h,k| # Table
-									h[k] = Hash.new {|h,k| #Field
-										h[k] = FieldEndpoint.new
-									}
-								}
-							}
-						}
+    class RouteEndpoint
+      attr_accessor :database
+      attr_accessor :database_queries_discovered
+      def initialize
+        @database_queries_discovered = {}
+        @database = Hash.new do |d_h, d_k| # Database
+          d_h[d_k] = Hash.new do |s_h, s_k| # Schema
+            s_h[s_k] = Hash.new do |t_h, t_k| # Table
+              t_h[t_k] = Hash.new do |f_h, f_k| # Field
+                f_h[f_k] = FieldEndpoint.new
+              end
+            end
+          end
+        end
+      end
+    end
 
-	    end
-  	end
-
-  	class RouteTable
-		attr_accessor :routes
-		def initialize
-	    	@routes = Hash.new { |h,k| h[k] = RouteEndpoint.new }
-	    end
-	end 
-
-  end #/module Routes
-end #/module TCellAgent
+    class RouteTable
+      attr_accessor :routes
+      def initialize
+        @routes = Hash.new { |h, k| h[k] = RouteEndpoint.new }
+      end
+    end
+  end
+end

data/lib/tcell_agent/rust/models.rb

@@ -1,18 +1,14 @@
 require 'tcell_agent/utils/strings'
 
-
 module TCellAgent
   module Rust
     module Models
-
       def self.convert_params(params_dict)
-        unless params_dict
-          return []
-        end
+        return [] unless params_dict
 
         flattened_params = []
         params_dict.each do |param_name, param_value|
-          flattened_params.push({"name" => param_name[-1], "value" => param_value})
+          flattened_params.push({ 'name' => param_name[-1], 'value' => param_value })
         end
 
         flattened_params
@@ -20,58 +16,57 @@ module TCellAgent
 
       def self.create_request_response(appsensor_meta)
         post_params = convert_params(appsensor_meta.flattened_post_dict) +
-          convert_params(appsensor_meta.flattened_body_dict)
+                      convert_params(appsensor_meta.flattened_body_dict)
 
         request_response = {
-          "method" =>  appsensor_meta.method,
-          "status_code" =>  appsensor_meta.response_code,
-          "route_id" =>  appsensor_meta.route_id,
-          "path" =>  appsensor_meta.path,
-          "query_params" =>  convert_params(appsensor_meta.flattened_get_dict),
-          "post_params" =>  post_params,
-          "headers" =>  convert_params(appsensor_meta.flattened_headers_dict),
-          "cookies" =>  convert_params(appsensor_meta.flattened_cookie_dict),
-          "path_params" =>  convert_params(appsensor_meta.flattened_path_parameters),
-          "remote_address" =>  appsensor_meta.remote_address,
-          "full_uri" =>  appsensor_meta.location,
-          "session_id" =>  appsensor_meta.session_id,
-          "user_id" =>  appsensor_meta.user_id,
-          "user_agent" =>  appsensor_meta.user_agent,
-          "request_bytes_length" =>  appsensor_meta.request_content_bytes_len,
-          "response_bytes_length" =>  appsensor_meta.response_content_bytes_len
+          'method' =>  appsensor_meta.method,
+          'status_code' =>  appsensor_meta.response_code.to_i,
+          'route_id' =>  appsensor_meta.route_id,
+          'path' =>  appsensor_meta.path,
+          'query_params' =>  convert_params(appsensor_meta.flattened_get_dict),
+          'post_params' =>  post_params,
+          'headers' =>  convert_params(appsensor_meta.flattened_headers_dict),
+          'cookies' =>  convert_params(appsensor_meta.flattened_cookie_dict),
+          'path_params' =>  convert_params(appsensor_meta.flattened_path_parameters),
+          'remote_address' =>  appsensor_meta.remote_address,
+          'full_uri' =>  appsensor_meta.location,
+          'session_id' =>  appsensor_meta.session_id,
+          'user_id' =>  appsensor_meta.user_id,
+          'user_agent' =>  appsensor_meta.user_agent,
+          'request_bytes_length' =>  appsensor_meta.request_content_bytes_len,
+          'response_bytes_length' =>  appsensor_meta.response_content_bytes_len
         }
 
         if TCellAgent::Utils::Strings.present?(appsensor_meta.csrf_exception_name)
-          request_response["csrf_exception"] = {"exception_name" => appsensor_meta.csrf_exception_name}
+          request_response['csrf_exception'] = { 'exception_name' => appsensor_meta.csrf_exception_name }
         end
 
         if appsensor_meta.sql_exceptions
-          request_response["sql_exceptions"] = appsensor_meta.sql_exceptions
+          request_response['sql_exceptions'] = appsensor_meta.sql_exceptions
         end
 
         if appsensor_meta.database_result_sizes
-          request_response["database_result_sizes"] = appsensor_meta.database_result_sizes
+          request_response['database_result_sizes'] = appsensor_meta.database_result_sizes
         end
 
-        return request_response
+        request_response
       end
 
       def self.create_patches_request(appsensor_meta)
         post_params = convert_params(appsensor_meta.flattened_post_dict) +
-          convert_params(appsensor_meta.flattened_body_dict)
+                      convert_params(appsensor_meta.flattened_body_dict)
 
         {
-          "method" =>  appsensor_meta.method,
-          "path" =>  appsensor_meta.path,
-          "remote_address" =>  appsensor_meta.remote_address,
-          "request_bytes_length" =>  appsensor_meta.request_content_bytes_len,
-          "query_params" =>  convert_params(appsensor_meta.flattened_get_dict),
-          "post_params" =>  post_params,
-          "headers" =>  convert_params(appsensor_meta.flattened_headers_dict),
-          "cookies" =>  convert_params(appsensor_meta.flattened_cookie_dict)
+          'method' =>  appsensor_meta.method,
+          'path' =>  appsensor_meta.path,
+          'remote_address' =>  appsensor_meta.remote_address,
+          'request_bytes_length' =>  appsensor_meta.request_content_bytes_len,
+          'query_params' =>  convert_params(appsensor_meta.flattened_get_dict),
+          'post_params' =>  post_params,
+          'headers' =>  convert_params(appsensor_meta.flattened_headers_dict),
+          'cookies' =>  convert_params(appsensor_meta.flattened_cookie_dict)
         }
       end
-
     end
   end
 end

data/lib/tcell_agent/rust/whisperer.rb

@@ -1,25 +1,24 @@
 require 'tcell_agent/rust/models'
 require 'tcell_agent/logger'
 
-
 module TCellAgent
   module Rust
-    require "ffi"
+    require 'ffi'
 
     module Wrapper
       extend FFI::Library
 
-      VERSION = "1.3.0"
-      prefix = "lib"
-      extension = ".so"
-      variant = ""
+      VERSION = '1.3.1'.freeze
+      prefix = 'lib'
+      extension = '.so'
+      variant = ''
       if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
-        extension = ".dll"
-        prefix = ""
+        extension = '.dll'
+        prefix = ''
       elsif /darwin/ =~ RUBY_PLATFORM
-        extension = ".dylib"
+        extension = '.dylib'
       elsif /musl/ =~ RUBY_PLATFORM
-        variant = "alpine-"
+        variant = 'alpine-'
       end
 
       begin
@@ -33,24 +32,24 @@ module TCellAgent
         #               -2 buffer_out is not big enough for response
         #               -3 buffer_out is null
 
-        attach_function :create_agent, [:pointer, :size_t, :pointer, :size_t], :int
+        attach_function :create_agent, %i[pointer size_t pointer size_t], :int
         attach_function :free_agent, [:pointer], :int
-        attach_function :update_policies, [:pointer, :pointer, :size_t, :pointer, :size_t], :int
-        attach_function :appfirewall_apply, [:pointer, :pointer, :size_t, :pointer, :size_t], :int
-        attach_function :patches_apply, [:pointer, :pointer, :size_t, :pointer, :size_t], :int
-        attach_function :cmdi_apply, [:pointer, :pointer, :size_t, :pointer, :size_t], :int
-        attach_function :get_headers, [:pointer, :pointer, :size_t, :pointer, :size_t], :int
-        attach_function :get_js_agent_script_tag, [:pointer, :pointer, :size_t, :pointer, :size_t], :int
+        attach_function :update_policies, %i[pointer pointer size_t pointer size_t], :int
+        attach_function :appfirewall_apply, %i[pointer pointer size_t pointer size_t], :int
+        attach_function :patches_apply, %i[pointer pointer size_t pointer size_t], :int
+        attach_function :cmdi_apply, %i[pointer pointer size_t pointer size_t], :int
+        attach_function :get_headers, %i[pointer pointer size_t pointer size_t], :int
+        attach_function :get_js_agent_script_tag, %i[pointer pointer size_t pointer size_t], :int
 
         def self.common_lib_available?
           true
         end
-
       rescue LoadError => load_error
         puts "tCell.io Failed to load common agent library. #{load_error.message}"
         TCellAgent.logger.error("Failed to load common agent library. #{load_error.message}")
         TCellAgent.logger.debug(load_error.backtrace)
-        def self.common_lib_available?
+
+        def self.common_lib_available? # rubocop:disable Lint/DuplicateMethods
           false
         end
       end
@@ -79,41 +78,40 @@ module TCellAgent
           end
         end
 
-        return {}
+        {}
       end
 
-      def self.create_agent()
+      def self.create_agent
         if TCellAgent::Rust::Wrapper.common_lib_available?
-          allow_payloads = !!TCellAgent.configuration.allow_payloads
           agent_config = {
-            "skip_logger" => true,
-            "application" => {
-              "app_id" => TCellAgent.configuration.app_id,
-              "api_key" =>  TCellAgent.configuration.api_key,
-              "allow_payloads" => allow_payloads,
-              "js_agent_api_base_url" => TCellAgent.configuration.js_agent_api_base_url,
-              "js_agent_url" => TCellAgent.configuration.js_agent_url
+            'skip_logger' => true,
+            'application' => {
+              'app_id' => TCellAgent.configuration.app_id,
+              'api_key' =>  TCellAgent.configuration.api_key,
+              'allow_payloads' => !!TCellAgent.configuration.allow_payloads, # rubocop:disable Style/DoubleNegation
+              'js_agent_api_base_url' => TCellAgent.configuration.js_agent_api_base_url,
+              'js_agent_url' => TCellAgent.configuration.js_agent_url
             },
-            "appfirewall" => {
-              "enable_body_xxe_inspection" => false,
-              "enable_body_json_inspection" => false,
-              "allow_log_payloads" => true
+            'appfirewall' => {
+              'enable_body_xxe_inspection' => false,
+              'enable_body_json_inspection' => false,
+              'allow_log_payloads' => true
             },
-            "policy_versions" => {
-              "patches" => 1,
-              "login" => 1,
-              "appsensor" => 2,
-              "regex" => 1,
-              "csp-headers" => 1,
-              "http-redirect" => 1,
-              "clickjacking" => 1,
-              "secure-headers" => 1,
-              "canaries" => 1,
-              "dlp" => 1,
-              "cmdi" => 1,
-              "jsagentinjection" => 1
+            'policy_versions' => {
+              'patches' => 1,
+              'login' => 1,
+              'appsensor' => 2,
+              'regex' => 1,
+              'csp-headers' => 1,
+              'http-redirect' => 1,
+              'clickjacking' => 1,
+              'secure-headers' => 1,
+              'canaries' => 1,
+              'dlp' => 1,
+              'cmdi' => 1,
+              'jsagentinjection' => 1
             },
-            "max_header_size" => TCellAgent.configuration.max_csp_header_bytes || (1024 * 1024)
+            'max_header_size' => TCellAgent.configuration.max_csp_header_bytes || (1024 * 1024)
           }
           config_pointer = FFI::MemoryPointer.from_string(
             JSON.dump(agent_config)
@@ -124,15 +122,15 @@ module TCellAgent
           result_size = TCellAgent::Rust::Wrapper.create_agent(
             config_pointer, config_pointer.size - 1, buf, buf.size
           )
-          return self.convert_result("create_agent", result_size, buf)
+          return convert_result('create_agent', result_size, buf)
         end
 
-        return {}
+        {}
       end
 
       def self.free_agent(agent_ptr)
         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-            agent_ptr
+           agent_ptr
           TCellAgent::Rust::Wrapper.free_agent(
             FFI::Pointer.new(agent_ptr)
           )
@@ -141,8 +139,8 @@ module TCellAgent
 
       def self.update_policies(agent_ptr, policies)
         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-            agent_ptr &&
-            TCellAgent::Utils::Strings.present?(policies)
+           agent_ptr &&
+           TCellAgent::Utils::Strings.present?(policies)
           policies_pointer = FFI::MemoryPointer.from_string(
             JSON.dump(policies)
           )
@@ -156,42 +154,42 @@ module TCellAgent
             buf,
             buf.size
           )
-          return self.convert_result("update_policies", result_size, buf)
+          return convert_result('update_policies', result_size, buf)
         end
 
-        return {}
+        {}
       end
 
       def self.apply_appfirewall(agent_ptr, appsensor_meta)
-         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-             agent_ptr &&
-             appsensor_meta
-           request_response_json = TCellAgent::Rust::Models.create_request_response(
-             appsensor_meta
-           )
-           request_response_pointer = FFI::MemoryPointer.from_string(
-             JSON.dump(request_response_json)
-           )
-
-           buf = FFI::MemoryPointer.new(:uint8, 1024 * 32)
-           # request_response_pointer.size - 1: strips null terminator
-           result_size = TCellAgent::Rust::Wrapper.appfirewall_apply(
-             FFI::Pointer.new(agent_ptr),
-             request_response_pointer,
-             request_response_pointer.size - 1,
-             buf,
-             buf.size
-           )
-           return self.convert_result("apply_appfirewall", result_size, buf)
-         end
-
-        return {}
+        if TCellAgent::Rust::Wrapper.common_lib_available? &&
+           agent_ptr &&
+           appsensor_meta
+          request_response_json = TCellAgent::Rust::Models.create_request_response(
+            appsensor_meta
+          )
+          request_response_pointer = FFI::MemoryPointer.from_string(
+            JSON.dump(request_response_json)
+          )
+
+          buf = FFI::MemoryPointer.new(:uint8, 1024 * 32)
+          # request_response_pointer.size - 1: strips null terminator
+          result_size = TCellAgent::Rust::Wrapper.appfirewall_apply(
+            FFI::Pointer.new(agent_ptr),
+            request_response_pointer,
+            request_response_pointer.size - 1,
+            buf,
+            buf.size
+          )
+          return convert_result('apply_appfirewall', result_size, buf)
+        end
+
+        {}
       end
 
       def self.apply_patches(agent_ptr, appsensor_meta)
         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-            agent_ptr &&
-            appsensor_meta
+           agent_ptr &&
+           appsensor_meta
           patches_request_json = TCellAgent::Rust::Models.create_patches_request(
             appsensor_meta
           )
@@ -208,23 +206,22 @@ module TCellAgent
             buf,
             buf.size
           )
-          return self.convert_result("apply_patches", result_size, buf)
+          return convert_result('apply_patches', result_size, buf)
         end
 
-        return {}
+        {}
       end
 
       def self.apply_cmdi(agent_ptr, command, tcell_context)
-
         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-            agent_ptr &&
-            TCellAgent::Utils::Strings.present?(command)
+           agent_ptr &&
+           TCellAgent::Utils::Strings.present?(command)
           method = tcell_context && tcell_context.request_method
           path = tcell_context && tcell_context.path
           command_info = {
-            "command" => command,
-            "method" => method,
-            "path" => path
+            'command' => command,
+            'method' => method,
+            'path' => path
           }
           command_pointer = FFI::MemoryPointer.from_string(
             JSON.dump(command_info)
@@ -239,25 +236,25 @@ module TCellAgent
             buf,
             buf.size
           )
-          return self.convert_result("apply_cmdi", result_size, buf)
+          return convert_result('apply_cmdi', result_size, buf)
         end
 
-        return {}
+        {}
       end
 
       def self.get_headers(agent_ptr, tcell_context)
         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-            agent_ptr &&
-            tcell_context
+           agent_ptr &&
+           tcell_context
           method = tcell_context.request_method
           path = tcell_context.path
           route_id = tcell_context.route_id
-          session_id = tcell_context.session_id
+          session_id = tcell_context.hmac_session_id
           headers_request = {
-            method: method,
-            path: path,
-            route_id: route_id && route_id.to_s,
-            session_id: session_id && session_id.to_s
+            :method => method,
+            :path => path,
+            :route_id => route_id && route_id.to_s,
+            :session_id => session_id && session_id.to_s
           }
           headers_request_pointer = FFI::MemoryPointer.from_string(
             JSON.dump(headers_request)
@@ -272,21 +269,21 @@ module TCellAgent
             buf,
             buf.size
           )
-          return self.convert_result("get_headers", result_size, buf)
+          return convert_result('get_headers', result_size, buf)
         end
 
-        return {}
+        {}
       end
 
       def self.get_js_agent_script_tag(agent_ptr, tcell_context)
         if TCellAgent::Rust::Wrapper.common_lib_available? &&
-            agent_ptr &&
-            tcell_context
+           agent_ptr &&
+           tcell_context
           method = tcell_context.request_method
           path = tcell_context.path
           jsagent_request = {
-            method: method,
-            path: path
+            :method => method,
+            :path => path
           }
           jsagent_request_pointer = FFI::MemoryPointer.from_string(
             JSON.dump(jsagent_request)
@@ -301,10 +298,10 @@ module TCellAgent
             buf,
             buf.size
           )
-          return self.convert_result("get_js_agent_script_tag", result_size, buf)
+          return convert_result('get_js_agent_script_tag', result_size, buf)
         end
 
-        return {}
+        {}
       end
     end
   end