skylight 5.0.1 → 5.1.1

data/lib/skylight/normalizers/grape/endpoint_run.rb

@@ -14,27 +14,25 @@ module Skylight
 
         private
 
-          def get_endpoint_name(endpoint)
-            method = get_method(endpoint)
-            path = get_path(endpoint)
-            namespace = get_namespace(endpoint)
-
-            if namespace && !namespace.empty?
-              path = "/#{path}" if path[0] != "/"
-              path = "#{namespace}#{path}"
-            end
-
-            "#{base_app_name(endpoint)} [#{method}] #{path}".strip
+        def get_endpoint_name(endpoint)
+          method = get_method(endpoint)
+          path = get_path(endpoint)
+          namespace = get_namespace(endpoint)
+
+          if namespace && !namespace.empty?
+            path = "/#{path}" if path[0] != "/"
+            path = "#{namespace}#{path}"
           end
 
-          def base_app_name(endpoint)
-            ep = endpoint.options[:for]
-            return ep.name if ep.name
+          "#{base_app_name(endpoint)} [#{method}] #{path}".strip
+        end
+
+        def base_app_name(endpoint)
+          ep = endpoint.options[:for]
+          return ep.name if ep.name
 
-            if ep.respond_to?(:base) && ep.base.respond_to?(:name)
-              ep.base.name
-            end
-          end
+          ep.base.name if ep.respond_to?(:base) && ep.base.respond_to?(:name)
+        end
       end
     end
   end

data/lib/skylight/normalizers/grape/endpoint_run_filters.rb

@@ -10,9 +10,7 @@ module Skylight
           filters = payload[:filters]
           type = payload[:type]
 
-          if (!filters || filters.empty?) || !type
-            return :skip
-          end
+          return :skip if (!filters || filters.empty?) || !type
 
           [CAT, "#{type.to_s.capitalize} Filters", nil]
         end

data/lib/skylight/normalizers/graphql/base.rb

@@ -25,12 +25,7 @@ module Skylight::Normalizers::GraphQL
 
     def self.inherited(klass)
       super
-      klass.const_set(
-        :KEY,
-        ActiveSupport::Inflector.underscore(
-          ActiveSupport::Inflector.demodulize(klass.name)
-        ).freeze
-      )
+      klass.const_set(:KEY, ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(klass.name)).freeze)
     end
 
     def self.key
@@ -43,15 +38,13 @@ module Skylight::Normalizers::GraphQL
 
     private
 
-      def key
-        self.class.key
-      end
+    def key
+      self.class.key
+    end
 
-      def extract_query_name(query)
-        query&.context&.[](:skylight_endpoint) ||
-          query&.operation_name ||
-          ANONYMOUS
-      end
+    def extract_query_name(query)
+      query&.context&.[](:skylight_endpoint) || query&.operation_name || ANONYMOUS
+    end
   end
 
   class Lex < Base
@@ -82,17 +75,21 @@ module Skylight::Normalizers::GraphQL
       # In graphql-ruby's case, the calculation of the operation name is lazy, and
       # has not been done yet at the point where execute_multiplex starts.
       # [1] https://graphql.org/learn/serving-over-http/#post-request
-      queries, has_errors = payload[:multiplex].queries.each_with_object([Set.new, Set.new]) do |query, (names, errors)|
-        names << extract_query_name(query)
-        errors << query.static_errors.any?
-      end
-
-      trace.endpoint = "graphql:#{queries.sort.join('+')}"
-      trace.compound_response_error_status = if has_errors.all?
-                                               :all
-                                             elsif has_errors.any?
-                                               :partial
-                                             end
+      queries, has_errors =
+        payload[:multiplex]
+          .queries
+          .each_with_object([Set.new, Set.new]) do |query, (names, errors)|
+            names << extract_query_name(query)
+            errors << query.static_errors.any?
+          end
+
+      trace.endpoint = "graphql:#{queries.sort.join("+")}"
+      trace.compound_response_error_status =
+        if has_errors.all?
+          :all
+        elsif has_errors.any?
+          :partial
+        end
     end
   end
 
@@ -106,9 +103,7 @@ module Skylight::Normalizers::GraphQL
     def normalize(trace, _name, payload)
       query_name = extract_query_name(payload[:query])
 
-      if query_name == ANONYMOUS
-        meta = { mute_children: true }
-      end
+      meta = { mute_children: true } if query_name == ANONYMOUS
 
       # This is probably always overriden by execute_multiplex#normalize_after,
       # but in the case of a single query, it will be the same value anyway.

data/lib/skylight/normalizers/render.rb

@@ -50,32 +50,30 @@ module Skylight
 
       private
 
-        def relative_path?(path)
-          !absolute_path?(path)
-        end
+      def relative_path?(path)
+        !absolute_path?(path)
+      end
 
-        SEPARATOR_BYTE = File::SEPARATOR.ord
+      SEPARATOR_BYTE = File::SEPARATOR.ord
 
-        if File.const_defined?(:NULL) ? File::NULL == "NUL" : RbConfig::CONFIG["host_os"] =~ /mingw|mswin32/
-          # This is a DOSish environment
-          ALT_SEPARATOR_BYTE = File::ALT_SEPARATOR&.ord
-          COLON_BYTE = ":".ord
-          SEPARATOR_BYTES = [SEPARATOR_BYTE, ALT_SEPARATOR_BYTE].freeze
+      if File.const_defined?(:NULL) ? File::NULL == "NUL" : RbConfig::CONFIG["host_os"] =~ /mingw|mswin32/
+        # This is a DOSish environment
+        ALT_SEPARATOR_BYTE = File::ALT_SEPARATOR&.ord
+        COLON_BYTE = ":".ord
+        SEPARATOR_BYTES = [SEPARATOR_BYTE, ALT_SEPARATOR_BYTE].freeze
 
-          def absolute_path?(path)
-            if alpha?(path.getbyte(0)) && path.getbyte(1) == COLON_BYTE
-              SEPARATOR_BYTES.include?(path.getbyte(2))
-            end
-          end
+        def absolute_path?(path)
+          SEPARATOR_BYTES.include?(path.getbyte(2)) if alpha?(path.getbyte(0)) && path.getbyte(1) == COLON_BYTE
+        end
 
-          def alpha?(byte)
-            (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
-          end
-        else
-          def absolute_path?(path)
-            path.getbyte(0) == SEPARATOR_BYTE
-          end
+        def alpha?(byte)
+          (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
+        end
+      else
+        def absolute_path?(path)
+          path.getbyte(0) == SEPARATOR_BYTE
         end
+      end
     end
   end
 end

data/lib/skylight/normalizers/shrine.rb

@@ -2,30 +2,28 @@ module Skylight
   module Normalizers
     class Shrine < Normalizer
       TITLES = {
-        "upload.shrine"           => "Upload",
-        "download.shrine"         => "Download",
-        "open.shrine"             => "Open",
-        "exists.shrine"           => "Exists",
-        "delete.shrine"           => "Delete",
-        "metadata.shrine"         => "Metadata",
-        "mime_type.shrine"        => "MIME Type",
+        "upload.shrine" => "Upload",
+        "download.shrine" => "Download",
+        "open.shrine" => "Open",
+        "exists.shrine" => "Exists",
+        "delete.shrine" => "Delete",
+        "metadata.shrine" => "Metadata",
+        "mime_type.shrine" => "MIME Type",
         "image_dimensions.shrine" => "Image Dimensions",
-        "signature.shrine"        => "Signature",
-        "extension.shrine"        => "Extension",
-        "derivation.shrine"       => "Derivation",
-        "derivatives.shrine"      => "Derivatives",
-        "data_uri.shrine"         => "Data URI",
-        "remote_url.shrine"       => "Remote URL"
+        "signature.shrine" => "Signature",
+        "extension.shrine" => "Extension",
+        "derivation.shrine" => "Derivation",
+        "derivatives.shrine" => "Derivatives",
+        "data_uri.shrine" => "Data URI",
+        "remote_url.shrine" => "Remote URL"
       }.freeze
 
-      TITLES.each_key do |key|
-        register key
-      end
+      TITLES.each_key { |key| register key }
 
       def normalize(_trace, name, _payload)
         title = ["Shrine", TITLES[name]].join(" ")
 
-        cat = "app.#{name.split('.').reverse.join('.')}"
+        cat = "app.#{name.split(".").reverse.join(".")}"
 
         [cat, title, nil]
       end

data/lib/skylight/normalizers/sql.rb

@@ -19,7 +19,7 @@ module Skylight
         when "SCHEMA", "CACHE"
           return :skip
         else
-          name  = CAT
+          name = CAT
           title = payload[:name] || "SQL"
         end
 
@@ -30,9 +30,9 @@ module Skylight
         unless sql.valid_encoding?
           if config[:log_sql_parse_errors]
             config.logger.error "[#{Skylight::SqlLexError.formatted_code}] Unable to extract binds from non-UTF-8 " \
-                                "query. " \
-                                "encoding=#{payload[:sql].encoding.name} " \
-                                "sql=#{payload[:sql].inspect} "
+                                  "query. " \
+                                  "encoding=#{payload[:sql].encoding.name} " \
+                                  "sql=#{payload[:sql].inspect} "
           end
 
           sql = nil

data/lib/skylight/probes.rb

@@ -26,31 +26,35 @@ module Skylight
 
       private
 
-        def log_install_exception(err)
-          description = err.class.to_s
-          description << ": #{err.message}" unless err.message.empty?
-
-          backtrace = err.backtrace.map { |l| "  #{l}" }.join("\n")
-
-          gems =
-            begin
-              Bundler.locked_gems.dependencies.map { |d| [d.name, d.requirement.to_s] }
-            rescue # rubocop:disable Lint/SuppressedException
-            end
-
-          error = "[SKYLIGHT] [#{Skylight::VERSION}] Encountered an error while installing the " \
-                          "probe for #{const_name}. Please notify support@skylight.io with the debugging " \
-                          "information below. It's recommended that you disable this probe until the " \
-                          "issue is resolved." \
-                          "\n\nERROR: #{description}\n\n#{backtrace}\n\n"
-
-          if gems
-            gems_string = gems.map { |g| "  #{g[0]}   #{g[1]}" }.join("\n")
-            error << "GEMS:\n\n#{gems_string}\n\n"
+      def log_install_exception(err)
+        description = err.class.to_s
+        description << ": #{err.message}" unless err.message.empty?
+
+        backtrace = err.backtrace.map { |l| "  #{l}" }.join("\n")
+
+        # rubocop:disable Lint/SuppressedException
+        gems =
+          begin
+            Bundler.locked_gems.dependencies.map { |d| [d.name, d.requirement.to_s] }
+          rescue StandardError
           end
 
-          $stderr.puts(error)
+        # rubocop:enable Lint/SuppressedException
+
+        error =
+          "[SKYLIGHT] [#{Skylight::VERSION}] Encountered an error while installing the " \
+            "probe for #{const_name}. Please notify support@skylight.io with the debugging " \
+            "information below. It's recommended that you disable this probe until the " \
+            "issue is resolved." \
+            "\n\nERROR: #{description}\n\n#{backtrace}\n\n"
+
+        if gems
+          gems_string = gems.map { |g| "  #{g[0]}   #{g[1]}" }.join("\n")
+          error << "GEMS:\n\n#{gems_string}\n\n"
         end
+
+        $stderr.puts(error)
+      end
     end
 
     class << self
@@ -62,11 +66,7 @@ module Skylight
         pending = registered.values - installed.values
 
         pending.each do |registration|
-          if registration.constant_available?
-            install_probe(registration)
-          else
-            register_require_hook(registration)
-          end
+          registration.constant_available? ? install_probe(registration) : register_require_hook(registration)
         end
       end
 
@@ -79,14 +79,14 @@ module Skylight
 
       def add_path(path)
         root = Pathname.new(path)
-        Pathname.glob(root.join("./**/*.rb")).each do |f|
-          name = f.relative_path_from(root).sub_ext("").to_s
-          if available.key?(name)
-            raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{f}"
-          end
+        Pathname
+          .glob(root.join("./**/*.rb"))
+          .each do |f|
+            name = f.relative_path_from(root).sub_ext("").to_s
+            raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{f}" if available.key?(name)
 
-          available[name] = f
-        end
+            available[name] = f
+          end
       end
 
       def available
@@ -95,13 +95,9 @@ module Skylight
 
       def probe(*probes)
         unknown = probes.map(&:to_s) - available.keys
-        unless unknown.empty?
-          raise ArgumentError, "unknown probes: #{unknown.join(', ')}"
-        end
+        raise ArgumentError, "unknown probes: #{unknown.join(", ")}" unless unknown.empty?
 
-        probes.each do |p|
-          require available[p.to_s]
-        end
+        probes.each { |p| require available[p.to_s] }
       end
 
       def registered
@@ -117,9 +113,7 @@ module Skylight
       end
 
       def register(name, *args)
-        if registered.key?(name)
-          raise "already registered: #{name}"
-        end
+        raise "already registered: #{name}" if registered.key?(name)
 
         registered[name] = ProbeRegistration.new(name, *args)
 
@@ -156,9 +150,7 @@ module Skylight
         return unless require_hooks.key?(require_path)
 
         # dup because we may be mutating the array
-        require_hooks[require_path].dup.each do |registration|
-          yield registration
-        end
+        require_hooks[require_path].dup.each { |registration| yield registration }
       end
     end
 

data/lib/skylight/probes/action_controller.rb

@@ -7,42 +7,46 @@ module Skylight
           ::ActionController::Instrumentation.class_eval do
             private
 
-              alias_method :append_info_to_payload_without_sk, :append_info_to_payload
-              def append_info_to_payload(payload)
-                append_info_to_payload_without_sk(payload)
+            alias_method :append_info_to_payload_without_sk, :append_info_to_payload
+            def append_info_to_payload(payload)
+              append_info_to_payload_without_sk(payload)
 
-                payload[:sk_rendered_format] = sk_rendered_mime.try(:ref)
-                payload[:sk_variant] = request.respond_to?(:variant) ? request.variant : nil
-              end
+              payload[:sk_rendered_format] = sk_rendered_mime.try(:ref)
+              payload[:sk_variant] = request.respond_to?(:variant) ? request.variant : nil
+            end
 
-              def sk_rendered_mime
-                if respond_to?(:media_type)
-                  mt = media_type
-                  return mt && Mime::Type.lookup(mt)
-                end
+            def sk_rendered_mime
+              if respond_to?(:media_type)
+                mt = media_type
+                return mt && Mime::Type.lookup(mt)
+              end
 
-                if content_type.is_a?(Mime::Type)
-                  content_type
-                elsif content_type.respond_to?(:to_s)
-                  type_str = content_type.to_s.split(";").first
-                  Mime::Type.lookup(type_str) unless type_str.blank?
-                elsif respond_to?(:rendered_format) && rendered_format
-                  rendered_format
-                end
-              rescue
-                # There are cases in which actionpack can return
-                # a stringified representation of a Mime::NullType instance,
-                # which is invalid for a number of reasons. This string raises
-                # errors when piped through Mime::Type.lookup, so it's probably
-                # best to just return nil in those cases.
-                nil
+              if content_type.is_a?(Mime::Type)
+                content_type
+              elsif content_type.respond_to?(:to_s)
+                type_str = content_type.to_s.split(";").first
+                Mime::Type.lookup(type_str) unless type_str.blank?
+              elsif respond_to?(:rendered_format) && rendered_format
+                rendered_format
               end
+            rescue StandardError
+              # There are cases in which actionpack can return
+              # a stringified representation of a Mime::NullType instance,
+              # which is invalid for a number of reasons. This string raises
+              # errors when piped through Mime::Type.lookup, so it's probably
+              # best to just return nil in those cases.
+              nil
+            end
           end
         end
       end
     end
 
-    register(:action_controller, "ActionController::Instrumentation", "action_controller/metal/instrumentation",
-             ActionController::Probe.new)
+    register(
+      :action_controller,
+      "ActionController::Instrumentation",
+      "action_controller/metal/instrumentation",
+      ActionController::Probe.new
+    )
   end
 end