tcell_agent 1.1.3 → 1.1.4

data/lib/tcell_agent/rails/on_start.rb

@@ -1,6 +1,6 @@
 # See the file "LICENSE" for the full license governing this code.
 
-#require 'tcell_agent/authlogic' if defined?(Authlogic)
+# require 'tcell_agent/authlogic' if defined?(Authlogic)
 
 require 'rails'
 
@@ -12,7 +12,7 @@ require 'tcell_agent/rails/dlp/process_request'
 TCellAgent::Instrumentation::Rails.send_language_info
 TCellAgent::Instrumentation::Rails.send_framework_info
 
-if (Rails.application)
+if Rails.application
   if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument?
     TCellAgent::Instrumentation::Rails.send_settings(Rails.application)
   end
@@ -20,17 +20,17 @@ if (Rails.application)
 else
   module TCellAgent
     class MyRailtie < Rails::Railtie
-      initializer 'activeservice.autoload', :after => :set_autoload_paths do |app|
+      initializer 'activeservice.autoload', :after => :set_autoload_paths do |_app|
         Rails.application.config.to_prepare do
           require 'tcell_agent/devise' if defined?(Devise)
           require 'tcell_agent/rails/auth/devise' if defined?(Devise)
           require 'tcell_agent/authlogic' if defined?(Authlogic)
-          require 'tcell_agent/rails/auth/authlogic'  if defined?(Authlogic)
+          require 'tcell_agent/rails/auth/authlogic' if defined?(Authlogic)
           require 'tcell_agent/rails/auth/doorkeeper'
         end
 
         # TODO: will this get run ever?
-        if (TCellAgent.configuration.enabled)
+        if TCellAgent.configuration.enabled
           Rails.application.config.after_initialize do
             TCellAgent::Instrumentation::Rails.send_settings(Rails.application)
           end

data/lib/tcell_agent/rails/responses.rb

@@ -1,26 +1,24 @@
 module TCellAgent
   module Utils
     module Rails
-
       STATUSES_MISSING_CONTENT_LENGTH = Set.new((100..199).to_a + [204, 205, 304])
 
       def self.empty_content?(status_code, headers)
-        return STATUSES_MISSING_CONTENT_LENGTH.include?(status_code.to_i) ||
-          (!!headers['Content-Length'] && headers['Content-Length'].to_i == 0)
+        STATUSES_MISSING_CONTENT_LENGTH.include?(status_code.to_i) ||
+          (headers['Content-Length'] && headers['Content-Length'].to_i.zero?)
       end
 
       def self.processable_response?(response_headers)
         content_disposition = response_headers['Content-Disposition']
-        is_attachment = content_disposition && !!(content_disposition =~ /^attachment/i)
+        is_attachment = content_disposition && content_disposition =~ /^attachment/i
 
         content_type = response_headers['Content-Type']
         applicable_content_type = content_type &&
-          (content_type == /application\/json/ ||
-           content_type == /application\/xml/ ||
-           !!(content_type =~ /^text/))
-        return !is_attachment && applicable_content_type
+                                  (content_type =~ %r{application/json}i ||
+                                   content_type =~ %r{application/xml}i ||
+                                   content_type =~ /^text/i)
+        !is_attachment && applicable_content_type
       end
-
     end
   end
 end

data/lib/tcell_agent/rails/routes.rb

@@ -1,6 +1,5 @@
 require 'tcell_agent/configuration'
 require 'tcell_agent/patches'
-require 'tcell_agent/patches/meta_data'
 require 'tcell_agent/rails/routes/grape'
 require 'tcell_agent/rails/routes/route_id'
 
@@ -8,9 +7,7 @@ require 'json'
 
 module TCellAgent
   module Instrumentation
-
     module Rails
-
       class TCellRoute
         attr_reader :route_id, :route_path, :route_path_raw, :route_destination
 
@@ -21,17 +18,15 @@ module TCellAgent
           @route_path = nil
           @route_destination = nil
 
-          if route
-            @route_path_raw = route.path.spec.to_s
+          return unless route
 
-            @route_path = @route_path_raw
-            @route_path = @route_path_raw.chomp("(.:format)")
+          @route_path_raw = route.path.spec.to_s
 
-            @route_destination = nil
-            if @route.defaults
-              @route_destination = JSON.dump(@route.defaults)
-            end
-          end
+          @route_path = @route_path_raw
+          @route_path = @route_path_raw.chomp('(.:format)')
+
+          @route_destination = nil
+          @route_destination = JSON.dump(@route.defaults) if @route.defaults
         end
 
         def report?
@@ -43,32 +38,29 @@ module TCellAgent
         end
 
         def grape_route?
-          TCellAgent::Instrumentation::grape_route?(@route)
+          TCellAgent::Instrumentation.grape_route?(@route)
         end
-
       end
 
       class TCellRoute5 < TCellRoute
-
         def report?
           TCellAgent::Utils::Strings.present?(@route.verb) || grape_route?
         end
 
         def route_methods
-          (@route.verb || "").split('|')
+          (@route.verb || '').split('|')
         end
 
         def grape_routes
           @route.app.app.routes
         end
-
       end
 
       class TCellRoute4 < TCellRoute
-        METHODS = %w[DELETE GET HEAD OPTIONS PATCH POST PUT TRACE CONNECT]
+        METHODS = %w[DELETE GET HEAD OPTIONS PATCH POST PUT TRACE CONNECT].freeze
 
         def report?
-          @route.constraints.has_key?(:request_method) || grape_route?
+          @route.constraints.key?(:request_method) || grape_route?
         end
 
         def route_methods
@@ -85,49 +77,44 @@ module TCellAgent
       end
 
       def self.create_tcell_route(route)
-        if route
-          if ::Rails::VERSION::MAJOR == 5
-            return TCellRoute5.new(route)
-          elsif ::Rails::VERSION::MAJOR < 5
-            return TCellRoute4.new(route)
-          end
-        end
+        return TCellRoute5.new(route) if route && ::Rails::VERSION::MAJOR == 5
+        return TCellRoute4.new(route) if route && ::Rails::VERSION::MAJOR < 5
 
         TCellRoute.new
       end
 
       def self.instrument_routes
-        if ::Rails.application
-          ::Rails.application.routes.routes.each do |route|
-            self.instrument_route(route)
-          end
+        return unless ::Rails.application
+
+        ::Rails.application.routes.routes.each do |route|
+          instrument_route(route)
         end
       end
 
       def self.instrument_route(route)
-        if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument?
-          tcell_route = create_tcell_route(route)
-
-          if tcell_route.report?
-            if tcell_route.grape_route?
-              TCellAgent::Instrumentation.instrument_grape_api(tcell_route.route_path, tcell_route.grape_routes)
-
-            else
-              tcell_route.route_methods.each do |route_method|
-                route_id =
-                  TCellAgent::SensorEvents::Util.calculateRouteId(route_method, tcell_route.route_path_raw)
-                TCellAgent.send_event(
-                  TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
-                    tcell_route.route_path, route_method, route_id, nil, tcell_route.route_destination
-                  )
-                )
-              end
-            end
+        return unless TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument?
+
+        tcell_route = create_tcell_route(route)
+
+        return unless tcell_route.report?
+
+        if tcell_route.grape_route?
+          TCellAgent::Instrumentation.instrument_grape_api(tcell_route.route_path, tcell_route.grape_routes)
+
+        else
+          tcell_route.route_methods.each do |route_method|
+            route_id =
+              TCellAgent::SensorEvents::Util.calculate_route_id(route_method, tcell_route.route_path_raw)
+            TCellAgent.send_event(
+              TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
+                tcell_route.route_path, route_method, route_id, nil, tcell_route.route_destination
+              )
+            )
           end
         end
       end
 
-      if (::Rails::VERSION::MAJOR == 3)
+      if ::Rails::VERSION::MAJOR == 3
         ActionDispatch::Routing::RouteSet.class_eval do
           alias_method :tcell_add_route, :add_route
           def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
@@ -141,46 +128,42 @@ module TCellAgent
 
         ActiveSupport.on_load(:action_controller) do
           ActionController::Base.class_eval do
-
-            if (::Rails::VERSION::MAJOR == 5)
+            if ::Rails::VERSION::MAJOR == 5
               prepend_around_action :tcell_around_filter_routes
-            elsif (::Rails::VERSION::MAJOR < 5)
+            elsif ::Rails::VERSION::MAJOR < 5
               prepend_around_filter :tcell_around_filter_routes
             end
             def tcell_around_filter_routes
-              begin
+              if TCellAgent.configuration.enabled &&
+                 TCellAgent.configuration.should_instrument? &&
+                 TCellAgent.configuration.should_intercept_requests?
+                TCellAgent::Instrumentation.safe_block('Determining Rails Route ID') do
+                  _match, parameters, route = ::Rails.application.routes.router.recognize(request) { |r, _| r }.first
 
-                if TCellAgent.configuration.enabled &&
-                    TCellAgent.configuration.should_instrument? &&
-                    TCellAgent.configuration.should_intercept_requests?
-                  TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
-                    match, parameters, route = ::Rails.application.routes.router.recognize(request) { |r, _| r }.first
-
-                    TCellAgent::Instrumentation::RouteId.update_context(env, parameters, route)
-                  end
-
-                  if TCellAgent::Instrumentation::Patches.block?(request)
-                    return head(403)
-                  end
+                  TCellAgent::Instrumentation::RouteId.update_context(env, parameters, route)
+                end
 
-                  TCellAgent::DLP.handle_request_dlp_parameters(request)
+                if TCellAgent::Instrumentation::Patches.block?(request)
+                  return head(403)
                 end
 
-                yield
+                TCellAgent::DLP.handle_request_dlp_parameters(request)
               end
+
+              yield
             end
           end
         end
 
       end
 
-      if (::Rails::VERSION::MAJOR == 4)
+      if ::Rails::VERSION::MAJOR == 4
         ActionDispatch::Journey::Routes.class_eval do
           alias_method :tcell_add_route, :add_route
           def add_route(app, path, conditions, defaults, name = nil)
             route = tcell_add_route(app, path, conditions, defaults, name)
 
-            TCellAgent::Instrumentation.safe_block("Reporting new route") do
+            TCellAgent::Instrumentation.safe_block('Reporting new route') do
               TCellAgent::Instrumentation::Rails.instrument_route(route)
             end
 
@@ -189,13 +172,13 @@ module TCellAgent
         end
       end
 
-      if (::Rails::VERSION::MAJOR == 5)
+      if ::Rails::VERSION::MAJOR == 5
         ActionDispatch::Journey::Routes.class_eval do
           alias_method :tcell_add_route, :add_route
           def add_route(name, mapping)
             route = tcell_add_route(name, mapping)
 
-            TCellAgent::Instrumentation.safe_block("Reporting new route") do
+            TCellAgent::Instrumentation.safe_block('Reporting new route') do
               TCellAgent::Instrumentation::Rails.instrument_route(route)
             end
 
@@ -204,14 +187,14 @@ module TCellAgent
         end
       end
 
-      if (::Rails::VERSION::MAJOR == 5 || (::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR >= 2))
+      if ::Rails::VERSION::MAJOR == 5 || (::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR >= 2)
         ActionDispatch::Journey::Router.class_eval do
           alias_method :tcell_serve, :serve
           def serve(req)
             if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? &&
-                TCellAgent.configuration.should_intercept_requests?
-              TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
-                match, parameters, route = find_routes(req).first
+               TCellAgent.configuration.should_intercept_requests?
+              TCellAgent::Instrumentation.safe_block('Determining Rails Route ID') do
+                _match, parameters, route = find_routes(req).first
 
                 TCellAgent::Instrumentation::RouteId.update_context(req.env, parameters, route)
               end
@@ -225,11 +208,10 @@ module TCellAgent
 
             tcell_serve(req)
           end
-
         end
       end
 
-      if (::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR < 2)
+      if ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR < 2
         require 'action_dispatch/journey/router/utils'
 
         ActionDispatch::Journey::Router.class_eval do
@@ -238,9 +220,9 @@ module TCellAgent
             env['PATH_INFO'] = ActionDispatch::Journey::Router::Utils.normalize_path(env['PATH_INFO'])
 
             if TCellAgent.configuration.enabled && TCellAgent.configuration.should_instrument? &&
-                TCellAgent.configuration.should_intercept_requests?
-              TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
-                match, parameters, route = find_routes(env).first
+               TCellAgent.configuration.should_intercept_requests?
+              TCellAgent::Instrumentation.safe_block('Determining Rails Route ID') do
+                _match, parameters, route = find_routes(env).first
 
                 TCellAgent::Instrumentation::RouteId.update_context(env, parameters, route)
               end
@@ -258,7 +240,6 @@ module TCellAgent
           end
         end
       end
-
     end
   end
 end

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

@@ -2,7 +2,6 @@ require 'tcell_agent/configuration'
 
 module TCellAgent
   module Instrumentation
-
     def self.grape_route?(route)
       if defined?(Grape::API)
         begin
@@ -15,7 +14,8 @@ module TCellAgent
           end
 
           return true
-        rescue StandardError
+        rescue StandardError # rubocop:disable Lint/HandleExceptions
+          # do nothing
         end
       end
 
@@ -23,26 +23,26 @@ module TCellAgent
     end
 
     def self.instrument_grape_api(grape_mount_endpoint, routes)
-      if routes
-        routes.each do |route|
-          route_info = grape_route_info(route)
-
-          route_path = "#{grape_mount_endpoint}#{route_info[:path]}"
-          route_method = route_info[:method]
-
-          route_id = TCellAgent::SensorEvents::Util.calculateRouteId(route_method, route_path)
-          TCellAgent.send_event(
-            TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
-              route_path, route_method, route_id, nil, nil
-            )
+      return unless routes
+
+      routes.each do |route|
+        route_info = grape_route_info(route)
+
+        route_path = "#{grape_mount_endpoint}#{route_info[:path]}"
+        route_method = route_info[:method]
+
+        route_id = TCellAgent::SensorEvents::Util.calculate_route_id(route_method, route_path)
+        TCellAgent.send_event(
+          TCellAgent::SensorEvents::AppRoutesSensorEvent.new(
+            route_path, route_method, route_id, nil, nil
           )
-        end
+        )
       end
     end
 
     def self.grape_route_info(route)
-      major, minor, tiny = Gem.loaded_specs['grape'].version.to_s.split('.')
-      if major.to_i == 0 && minor.to_i < 16
+      major, minor, _tiny = Gem.loaded_specs['grape'].version.to_s.split('.')
+      if major.to_i.zero? && minor.to_i < 16
         {
           :method => route.route_method,
           :path => route.route_path
@@ -56,8 +56,8 @@ module TCellAgent
     end
 
     def self.grape_route_params(route)
-      major, minor, tiny = Gem.loaded_specs['grape'].version.to_s.split('.')
-      if major.to_i == 0 && minor.to_i < 16
+      major, minor, _tiny = Gem.loaded_specs['grape'].version.to_s.split('.')
+      if major.to_i.zero? && minor.to_i < 16
         route.route_params
       else
         route.params
@@ -68,25 +68,21 @@ module TCellAgent
       def self.grape_path_params(env, route)
         all_params = Grape::Request.new(env).params
 
-        self.grape_route_params(route).keys.inject({})do |memo, key|
+        grape_route_params(route).keys.each_with_object({}) do |key, memo|
           memo[key] = all_params[key]
-
-          memo
         end
       end
 
       Grape::Endpoint.class_eval do
-
         alias_method :tcell_call!, :call!
         def call!(env)
           if TCellAgent.configuration.enabled &&
-              TCellAgent.configuration.should_instrument? &&
-              TCellAgent.configuration.should_intercept_requests?
-
-            TCellAgent::Instrumentation.safe_block("Determining Rails Route ID") do
+             TCellAgent.configuration.should_instrument? &&
+             TCellAgent.configuration.should_intercept_requests?
 
+            TCellAgent::Instrumentation.safe_block('Determining Rails Route ID') do
               tcell_context = env[TCellAgent::Instrumentation::TCELL_ID]
-              if tcell_context && tcell_context.grape_mount_endpoint && self.respond_to?(:routes)
+              if tcell_context && tcell_context.grape_mount_endpoint && respond_to?(:routes)
                 route = routes.first
 
                 if route
@@ -96,7 +92,7 @@ module TCellAgent
                   if route_path
                     tcell_context.path_parameters = TCellAgent::Instrumentation.grape_path_params(env, route)
                     tcell_context.route_id =
-                      TCellAgent::SensorEvents::Util.calculateRouteId(tcell_context.request_method, route_path)
+                      TCellAgent::SensorEvents::Util.calculate_route_id(tcell_context.request_method, route_path)
                   end
                 end
               end
@@ -108,6 +104,5 @@ module TCellAgent
       end
 
     end
-
   end
 end