tcell_agent 2.0.0 → 2.5.0

data/lib/tcell_agent/rust/native_agent.rb

@@ -9,53 +9,18 @@ require 'tcell_agent/utils/headers'
 module TCellAgent
   module Rust
     class NativeAgent # rubocop:disable Metrics/ClassLength
-      def self.test_event_sender(events)
-        config = TCellAgent.configuration
-        event_sender = {
-          :uuid =>            config.uuid,
-          :hostname =>        config.host_identifier,
-          :agent_type =>      'Ruby',
-          :agent_version =>   TCellAgent::VERSION,
-          :app_id =>          config.app_id,
-          :api_key =>         config.api_key,
-          :tcell_input_url => config.tcell_input_url,
-          :events =>          events
-        }
-        event_sender_pointer = FFI::MemoryPointer.from_string(
-          JSON.dump(event_sender)
-        )
-
-        buf = FFI::MemoryPointer.new(:uint8, 1024 * 8)
-        # config_pointer.size - 1: strips null terminator
-        result_size = TCellAgent::Rust::NativeLibrary.test_event_sender(
-          event_sender_pointer, event_sender_pointer.size - 1, buf, buf.size
-        )
-
-        response = NativeAgentResponse.new('test_event_sender', buf, result_size)
-
-        response.errors
-      end
+      def self.test_agent(config)
+        agent_config = TCellAgent::Rust::AgentConfig.new(config)
 
-      def self.test_policies
-        config = TCellAgent.configuration
-        policies_info = {
-          :app_id =>        config.app_id,
-          :api_key =>       config.api_key,
-          :tcell_api_url => config.tcell_api_url
-        }
-        policies_info_pointer = FFI::MemoryPointer.from_string(
-          JSON.dump(policies_info)
+        config_pointer = FFI::MemoryPointer.from_string(
+          JSON.dump(agent_config)
         )
 
         buf = FFI::MemoryPointer.new(:uint8, 1024 * 8)
         # config_pointer.size - 1: strips null terminator
-        result_size = TCellAgent::Rust::NativeLibrary.test_policies(
-          policies_info_pointer, policies_info_pointer.size - 1, buf, buf.size
+        TCellAgent::Rust::NativeLibrary.test_agent(
+          config_pointer, config_pointer.size - 1, buf, buf.size
         )
-
-        response = NativeAgentResponse.new('test_event_sender', buf, result_size)
-
-        response.errors
       end
 
       def self.free_agent(agent_ptr)
@@ -88,6 +53,9 @@ module TCellAgent
           return nil
         end
 
+        return unless response['config'] && response['agent_enabled']
+
+        TCellAgent.configuration.populate_configuration(response['config'])
         NativeAgent.new(response['agent_ptr'])
       end
 
@@ -116,6 +84,7 @@ module TCellAgent
           :headers => header_params,
           :cookies => cookie_params,
           :path_params => path_params,
+          :reverse_proxy_header_value => appsensor_meta.reverse_proxy_header_value,
           :remote_address => appsensor_meta.remote_address,
           :full_uri => appsensor_meta.location,
           :session_id => appsensor_meta.session_id,
@@ -126,7 +95,6 @@ module TCellAgent
           :content_type => appsensor_meta.content_type,
           :request_body => appsensor_meta.raw_request_body
         }
-
         request_response_json[:sql_exceptions] = appsensor_meta.sql_exceptions if appsensor_meta.sql_exceptions
         request_response_json[:database_result_sizes] = appsensor_meta.database_result_sizes if appsensor_meta.database_result_sizes
 
@@ -167,13 +135,15 @@ module TCellAgent
           :method => appsensor_meta.method,
           :path => appsensor_meta.path,
           :remote_address => appsensor_meta.remote_address,
+          :reverse_proxy_header_value => appsensor_meta.reverse_proxy_header_value,
           :request_bytes_length => appsensor_meta.request_content_bytes_len,
           :query_params => query_params,
-          :post_params =>  post_params,
+          :post_params => post_params,
           :headers => header_params,
           :cookies => cookie_params,
           :content_type => appsensor_meta.content_type,
-          :full_uri => appsensor_meta.location
+          :full_uri => appsensor_meta.location,
+          :request_body => appsensor_meta.raw_request_body
         }
 
         patches_request_pointer = FFI::MemoryPointer.from_string(
@@ -196,6 +166,37 @@ module TCellAgent
         response.response
       end
 
+      def apply_suspicious_quick_check(appsensor_meta)
+        return {} unless appsensor_meta
+
+        sus_quick_check_request_json = {
+          :reverse_proxy_header_value => appsensor_meta.reverse_proxy_header_value,
+          :method => appsensor_meta.method,
+          :path => appsensor_meta.path,
+          :full_uri => appsensor_meta.location,
+          :request_bytes_length => appsensor_meta.request_content_bytes_len
+        }
+
+        if appsensor_meta.reverse_proxy_header_value.nil?
+          sus_quick_check_request_json.merge(
+            {
+              :client_ip_override => appsensor_meta.remote_address
+            }
+          )
+        end
+
+        sus_quick_check_request_ptr = FFI::MemoryPointer.from_string(
+          JSON.dump(sus_quick_check_request_json)
+        )
+
+        # sus_quick_check_request_ptr.size - 1: strips null terminator
+        TCellAgent::Rust::NativeLibrary.suspicious_quick_check_apply(
+          FFI::Pointer.new(@agent_ptr),
+          sus_quick_check_request_ptr,
+          sus_quick_check_request_ptr.size - 1
+        )
+      end
+
       def apply_cmdi(command, tcell_context)
         return unless TCellAgent::Utils::Strings.present?(command)
 
@@ -203,12 +204,14 @@ module TCellAgent
           :command => command,
           :method => tcell_context.request_method,
           :path => tcell_context.path,
+          :reverse_proxy_header_value => tcell_context.reverse_proxy_header_value,
           :remote_address => tcell_context.remote_address,
           :route_id => tcell_context.route_id,
           :session_id => tcell_context.session_id,
           :user_id => tcell_context.user_id,
           :full_uri => tcell_context.uri
         }
+
         command_pointer = FFI::MemoryPointer.from_string(
           JSON.dump(command_info)
         )
@@ -229,10 +232,11 @@ module TCellAgent
         response.response
       end
 
-      def get_headers(tcell_context)
+      def get_headers(content_type, tcell_context)
         return unless tcell_context
 
         headers_request = {
+          :content_type => content_type,
           :method => tcell_context.request_method,
           :path => tcell_context.path,
           :route_id => tcell_context.route_id.to_s,
@@ -270,8 +274,9 @@ module TCellAgent
           :status_code => status_code,
           :method => tcell_context.request_method,
           :path => tcell_context.path,
+          :reverse_proxy_header_value => tcell_context.reverse_proxy_header_value,
           :remote_addr => tcell_context.remote_address,
-          :full_uri => tcell_context.fullpath,
+          :full_uri => tcell_context.uri,
           :route_id => tcell_context.route_id,
           :session_id => tcell_context.session_id,
           :user_id => tcell_context.user_id
@@ -335,11 +340,12 @@ module TCellAgent
           :event_name => event_name,
           :user_id => user_id,
           :user_agent => tcell_context.user_agent,
+          :reverse_proxy_header_value => tcell_context.reverse_proxy_header_value,
           :remote_address => tcell_context.remote_address,
           :header_keys => header_keys,
-          :passsword => password,
+          :password => password,
           :session_id => tcell_context.session_id,
-          :full_uri => tcell_context.fullpath,
+          :full_uri => tcell_context.uri,
           :referrer => tcell_context.referrer,
           :user_valid => user_valid
         }
@@ -377,11 +383,14 @@ module TCellAgent
         if tcell_context
           file_access_info = file_access_info.merge(
             {
-              :full_uri => tcell_context.fullpath,
+              :full_uri => tcell_context.uri,
+              :reverse_proxy_header_value => tcell_context.reverse_proxy_header_value,
               :remote_address => tcell_context.remote_address,
               :route_id => tcell_context.route_id,
               :session_id => tcell_context.session_id,
-              :user_id => tcell_context.user_id
+              :user_id => tcell_context.user_id,
+              :method => tcell_context.request_method,
+              :request_path => tcell_context.path
             }
           )
         end
@@ -453,6 +462,7 @@ module TCellAgent
           :session_id => tcell_context && tcell_context.session_id,
           :user_id => tcell_context && tcell_context.user_id,
           :user_agent => tcell_context && tcell_context.user_agent,
+          :reverse_proxy_header_value => tcell_context.reverse_proxy_header_value,
           :remote_address => tcell_context && tcell_context.remote_address
         }
         message_pointer = FFI::MemoryPointer.from_string(
@@ -504,7 +514,7 @@ module TCellAgent
         end
       end
 
-      # Note: for tests
+      # NOTE: for tests
       def update_policies(policies)
         return {} unless TCellAgent::Utils::Strings.present?(policies)
 

data/lib/tcell_agent/rust/native_library.rb

@@ -6,22 +6,20 @@ module TCellAgent
       require 'ffi'
       extend FFI::Library
 
-      VERSION = '4.14.0'.freeze
-      prefix = 'lib'
       extension = '.so'
       variant = ''
       if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
+        variant = '-x64'
         extension = '.dll'
-        prefix = ''
       elsif /darwin/ =~ RUBY_PLATFORM
         extension = '.dylib'
       elsif /musl/ =~ RUBY_PLATFORM
-        variant = 'alpine-'
+        variant = '-alpine'
       end
 
       begin
         ffi_lib File.join(File.dirname(__FILE__),
-                          "#{prefix}tcellagent-#{variant}#{VERSION}#{extension}")
+                          "libtcellagent#{variant}#{extension}")
 
         # All the rust library calls have the following response api:
         #
@@ -36,6 +34,7 @@ module TCellAgent
         attach_function :poll_new_policies, %i[pointer 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 :suspicious_quick_check_apply, %i[pointer 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
@@ -48,16 +47,15 @@ module TCellAgent
         attach_function :log_message, %i[pointer pointer size_t pointer size_t], :int
 
         attach_function :update_policies, %i[pointer pointer size_t pointer size_t], :int
-        attach_function :test_event_sender, %i[pointer size_t pointer size_t], :int
-        attach_function :test_policies, %i[pointer size_t pointer size_t], :int
+        attach_function :test_agent, %i[pointer size_t pointer size_t], :int
 
         def self.common_lib_available?
           true
         end
-      rescue LoadError => load_error
+      rescue LoadError => e
         logger = TCellAgent::ModuleLogger.new(TCellAgent::RubyLogger.new, name)
-        logger.error("Failed loading agent library. #{load_error.message}")
-        logger.exception(load_error)
+        logger.error("Failed loading agent library. #{e.message}")
+        logger.exception(e)
 
         def self.common_lib_available? # rubocop:disable Lint/DuplicateMethods
           false

data/lib/tcell_agent/sensor_events/server_agent.rb

@@ -7,59 +7,6 @@ require 'etc'
 
 module TCellAgent
   module SensorEvents
-    class ServerAgentDetailsSensorEvent < TCellSensorEvent
-      include TCellAgent::ModuleLoggerAccess
-
-      def initialize
-        super('server_agent_details')
-        @flush = true
-        @ensure = true
-
-        self['user'] = 'unknown'
-        self['group'] = 'unknown'
-
-        begin
-          login = Etc.getlogin
-          if login
-            self['user'] = login
-            begin
-              info = Etc.getpwnam(login)
-              self['group'] = info.gid.to_s
-            rescue StandardError => te
-              module_logger.debug("Could not get group id: #{te.message}")
-              module_logger.exception(te)
-            end
-          end
-        rescue StandardError => to
-          module_logger.debug("Could not get user & group: #{to.message}")
-          module_logger.exception(te)
-        end
-
-        module_logger.debug("User #{self['user']}")
-        module_logger.debug("Group #{self['group']}")
-      end
-    end
-
-    class ServerAgentDetailsLanguageEvent < TCellSensorEvent
-      def initialize(language, language_version)
-        super('server_agent_details')
-        @flush = true
-        @ensure = true
-        self['language'] = language
-        self['language_version'] = language_version
-      end
-    end
-
-    class ServerAgentAppFrameworkEvent < TCellSensorEvent
-      def initialize(framework_name, framework_version)
-        super('server_agent_details')
-        @flush = true
-        @ensure = true
-        self['app_framework'] = framework_name
-        self['app_framework_version'] = framework_version
-      end
-    end
-
     class ServerAgentPackagesSensorEvent < TCellSensorEvent
       include TCellAgent::ModuleLoggerAccess
 
@@ -75,59 +22,15 @@ module TCellAgent
               packages.push(package)
               module_logger.debug("Adding packages #{x.name}")
             end
-          rescue StandardError => te
-            module_logger.error("Exception adding package: #{te.message}")
-            module_logger.exception(te)
+          rescue StandardError => e
+            module_logger.error("Exception adding package: #{e.message}")
+            module_logger.exception(e)
           end
         end
         self['packages'] = packages
       end
     end
 
-    class AppFramework < TCellSensorEvent
-      def initialize(name, version)
-        super('appserver_framework')
-        @flush = false
-        @ensure = true
-        self['n'] = name
-        self['v'] = version
-      end
-    end
-
-    class AppAuthFramework < TCellSensorEvent
-      def initialize(name, version)
-        super('appserver_auth_framework')
-        @flush = false
-        @ensure = true
-        self['n'] = name
-        self['v'] = version
-      end
-    end
-
-    class AppFrameworkSetting < TCellSensorEvent
-      def initialize(framework_name, setting, value)
-        super('appserver_framework_setting')
-        @flush = false
-        @ensure = true
-        self['framework'] = framework_name
-        self['s'] = setting
-        self['v'] = value
-      end
-    end
-
-    class AppCookie < TCellSensorEvent
-      def initialize(name, value, secure, http_only, session)
-        super('appserver_framework_setting')
-        @flush = false
-        @ensure = true
-        self['n'] = name
-        self['v'] = value
-        self['http_only'] = http_only
-        self['secure'] = secure
-        self['session'] = session
-      end
-    end
-
     class AppRoutesSensorEvent < TCellSensorEvent
       def initialize(uri, method, route_id, params = nil, destination = nil)
         super('appserver_routes')

data/lib/tcell_agent/sensor_events/util/sanitizer_utilities.rb

@@ -19,6 +19,7 @@ module TCellAgent
         params = CGI.parse(query)
         params.each do |param_name, param_values|
           next if param_values.nil? || param_values.empty?
+
           params[param_name] = ['']
         end
         params.map { |k, v| "#{k}=#{v.join(',')}" }.join('&')

data/lib/tcell_agent/servers/puma.rb

@@ -1,38 +1,55 @@
 if defined?(Puma.cli_config)
   if Puma.cli_config.options[:preload_app]
-    if Puma.cli_config.options[:workers] == 0 # rubocop:disable Style/NumericPredicate
+    if Puma.cli_config.options[:workers] == 0
       # Puma is running in single mode, so run both the initial instrumentation and
       # start the agent
       Puma::Runner.class_eval do
-        alias_method :original_start_server, :start_server
+        alias_method :tcell_original_start_server, :start_server
         def start_server
-          TCellAgent.thread_agent.start('Puma Single Mode')
+          TCellAgent.thread_agent.start('Puma')
 
-          original_start_server
+          tcell_original_start_server
         end
       end
 
     else
       Puma::Server.class_eval do
-        alias_method :original_run, :run
-        def run(background = true)
-          TCellAgent.thread_agent.start('Puma Cluster Mode (Worker)')
+        alias_method :tcell_original_run, :run
 
-          original_run(background)
+        if defined?(Gem::Version) &&
+           defined?(Puma::Const::PUMA_VERSION) &&
+           (Gem::Version.new(Puma::Const::PUMA_VERSION) < Gem::Version.new('5.1.0'))
+          def run(background = true)
+            TCellAgent.thread_agent.start('Puma')
+            original_run(background, options)
+          end
+        else
+          def run(background = true, thread_name: 'server')
+            TCellAgent.thread_agent.start('Puma')
+            original_run(background, :thread_name => thread_name)
+          end
         end
       end
     end
-
   else
     # this ensures instrumentation runs for preload_app = false.
     # Instrumentation will run for each worker but there's
     # nothing we can do about that (Unicorn's preload_app behaves the same way)
     Puma::Server.class_eval do
-      alias_method :original_run, :run
-      def run(background = true)
-        TCellAgent.thread_agent.start('Puma Cluster Mode (Worker)')
+      alias_method :tcell_original_run, :run
 
-        original_run(background)
+      if defined?(Gem::Version) &&
+         defined?(Puma::Const::PUMA_VERSION) &&
+         (Gem::Version.new(Puma::Const::PUMA_VERSION) < Gem::Version.new('5.1.0'))
+        def run(background = true)
+          TCellAgent.thread_agent.start('Puma')
+          tcell_original_run(background)
+        end
+      else
+        def run(background = true, thread_name: 'server')
+          TCellAgent.thread_agent.start('Puma')
+          original_run(background, :thread_name => thread_name)
+        end
       end
     end
   end

data/lib/tcell_agent/servers/rack_puma_handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Rack::Handler::Puma.class_eval do
+  class << self
+    alias_method :tcell_original_config, :config
+    def config(app, options = {})
+      conf = tcell_original_config(app, options)
+
+      if defined?(Puma::Server) && !Puma::Server.instance_methods.include?(:tcell_original_run)
+        Puma::Server.class_eval do
+          alias_method :tcell_original_run, :run
+
+          if defined?(Gem::Version) &&
+             defined?(Puma::Const::PUMA_VERSION) &&
+             (Gem::Version.new(Puma::Const::PUMA_VERSION) >= Gem::Version.new('5.1.0'))
+            def run(background = true, thread_name: 'server')
+              TCellAgent.thread_agent.start('Puma')
+              original_run(background, :thread_name => thread_name)
+            end
+          else
+            def run(background = true)
+              TCellAgent.thread_agent.start('Puma')
+
+              tcell_original_run(background)
+            end
+          end
+        end
+      end
+
+      conf
+    end
+  end
+end

data/lib/tcell_agent/servers/rails_server.rb

@@ -5,17 +5,17 @@
 Rails::Server.class_eval do
   alias_method :tcell_build_app, :build_app
   def build_app(app)
+    require('tcell_agent/servers/rack_puma_handler') if defined?(Rack::Handler::Puma)
     require('tcell_agent/servers/unicorn') if defined?(Unicorn::HttpServer)
     require('tcell_agent/servers/webrick') if defined?(Rack::Handler::WEBrick)
     require('tcell_agent/servers/thin') if defined?(Thin::Server)
 
     if defined?(Puma::Server)
       Puma::Server.class_eval do
-        alias_method :original_run, :run
+        alias_method :tcell_original_run, :run
         def run(background = true)
-          TCellAgent.thread_agent.start('Puma Single Mode')
-
-          original_run(background)
+          TCellAgent.thread_agent.start('Puma')
+          tcell_original_run(background)
         end
       end
     end

data/lib/tcell_agent/servers/unicorn.rb

@@ -3,7 +3,7 @@ Unicorn::HttpServer.class_eval do
   # - This check also ensures that a server is running as opposed to a different command such
   # as `bundle exec rails runner User.count`.
   unless Unicorn::HttpServer::START_CTX && Unicorn::HttpServer::START_CTX[0]
-    require 'tcell_agent/rails/start_agent_after_initializers'
+    require 'tcell_agent/rails/railties/tcell_agent_unicorn_railties'
   end
 
   # This only gets instrumented when preload_app is true

data/lib/tcell_agent/servers/webrick.rb

@@ -1,10 +1,19 @@
 Rack::Handler::WEBrick.class_eval do
   class << self
     alias_method :original_run, :run
-    def run(app, options = {})
-      TCellAgent.thread_agent.start('WEBrick')
 
-      original_run(app, options)
+    if defined?(Gem::Version) &&
+       defined?(Rack.release) &&
+       Gem::Version.new(Rack.release) < Gem::Version.new('2.2.0')
+      def run(app, options = {})
+        TCellAgent.thread_agent.start('WEBrick')
+        original_run(app, options)
+      end
+    else
+      def run(app, **options)
+        TCellAgent.thread_agent.start('WEBrick')
+        original_run(app, **options)
+      end
     end
   end
 end

data/lib/tcell_agent/settings_reporter.rb

@@ -7,25 +7,11 @@ require 'thread'
 module TCellAgent
   def self.report_settings
     Thread.new do
-      TCellAgent::Instrumentation.safe_block('Instrumenting Agent Details') do
-        event = TCellAgent::SensorEvents::ServerAgentDetailsSensorEvent.new
-        TCellAgent.send_event(event)
-      end
-
       TCellAgent::Instrumentation.safe_block('Instrumenting Server Packages') do
         event = TCellAgent::SensorEvents::ServerAgentPackagesSensorEvent.new
         TCellAgent.send_event(event)
       end
 
-      TCellAgent::Instrumentation.safe_block('Instrumenting Language Info') do
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::ServerAgentDetailsLanguageEvent.new(
-            'Ruby',
-            RUBY_VERSION
-          )
-        )
-      end
-
       TCellAgent::Instrumentation.safe_block('Instrumenting Native Lib Status') do
         require 'tcell_agent/rust/native_agent'
 
@@ -37,85 +23,6 @@ module TCellAgent
         )
       end
 
-      TCellAgent::Instrumentation.safe_block('Instrumenting Initial Config') do
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::AgentSettingEvent.new(
-            'allow_payloads',
-            (!!TCellAgent.configuration.allow_payloads).to_s # rubocop:disable Style/DoubleNegation
-          )
-        )
-
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::AgentSettingEvent.new(
-            'reverse_proxy',
-            (!!TCellAgent.configuration.reverse_proxy).to_s # rubocop:disable Style/DoubleNegation
-          )
-        )
-
-        # Because of all the diff ways to initialize the agent
-        # some some of the following vars might not be set until
-        # we call this method, so call this method to set all
-        # the variables
-        TCellAgent.configuration.log_filename
-
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::AgentSettingEvent.new(
-            'config_filename',
-            TCellAgent.configuration.config_filename
-          )
-        )
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::AgentSettingEvent.new(
-            'logging_directory',
-            TCellAgent.configuration.agent_log_dir
-          )
-        )
-
-        TCellAgent.send_event(
-          TCellAgent::SensorEvents::AgentSettingEvent.new(
-            'agent_home_directory',
-            TCellAgent.configuration.agent_home_dir
-          )
-        )
-
-        logging_options = TCellAgent.configuration.logging_options || {}
-        use_default_setting = !logging_options.key?(:enabled) && !logging_options.key?('enabled')
-        if use_default_setting || logging_options[:enabled] || logging_options['enabled']
-          TCellAgent.send_event(
-            TCellAgent::SensorEvents::AgentSettingEvent.new('logging_enabled', 'true')
-          )
-
-          TCellAgent.send_event(
-            TCellAgent::SensorEvents::AgentSettingEvent.new(
-              'logging_level',
-              logging_options[:level] || logging_options['level'] || 'INFO'
-            )
-          )
-        else
-          TCellAgent.send_event(
-            TCellAgent::SensorEvents::AgentSettingEvent.new('logging_enabled', 'false')
-          )
-        end
-
-        if TCellAgent.configuration.hmac_key
-          TCellAgent.send_event(
-            TCellAgent::SensorEvents::AgentSettingEvent.new(
-              'hmac_key_present',
-              (!!TCellAgent.configuration.hmac_key).to_s # rubocop:disable Style/DoubleNegation
-            )
-          )
-        end
-
-        if TCellAgent.configuration.reverse_proxy
-          TCellAgent.send_event(
-            TCellAgent::SensorEvents::AgentSettingEvent.new(
-              'reverse_proxy_ip_address_header',
-              TCellAgent.configuration.reverse_proxy_ip_address_header
-            )
-          )
-        end
-      end
-
       if defined?(::Rails)
         TCellAgent::Instrumentation.safe_block('Instrumenting routes') do
           TCellAgent::Instrumentation::Rails.instrument_routes