skylight-core 4.2.0 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a473587df8be0c1cf35b0296875e2cbd3c47d678be913e61c770e7d29d30756a
-  data.tar.gz: d637956868b2c614225343bf10a063038778df91418053222d7a5e5038fcaa69
+  metadata.gz: 2443077b98bc42af5683f82aac17e192670026cbd6bdfa9a940caff2237860a0
+  data.tar.gz: e0dc413f3f0d0827f4b064b8fdfbac13f607357113ed50a223f9522e5775b5e0
 SHA512:
-  metadata.gz: 91aebd0cfa951251a62903542df63949db425718233e178d362318bce81e4ccd865372e4d1cd9891d1adc09d87d8ac182daf5e5c6c7ded5b81f800ba1faa3374
-  data.tar.gz: 4d442162789bcbd47ae5bc37fabdaf49650c0fb4f7fc8b50c6a4c2c63cfe6271cd66191db27114d9985ffdcaf5a82effad58984065411b469d9cafa064f3ed63
+  metadata.gz: e3ae4c018808967cf5b0cec1fb9056c037f37c2cd60b1790759755d1d9e05cba3f400a790502110fa5723541ad03f0fcf50eeb0d3ebc546d9ff19eb3c8d00309
+  data.tar.gz: ca5ca4747d2ec5a578f830dc5ee1ef818a651ca9a9f95ad069cfd26849014279f9aa4f9d3f2040eaf6de8ea64501959fbab005800c96107d17fe9f92b572517c

data/lib/skylight/core/middleware.rb

@@ -44,17 +44,31 @@ module Skylight::Core
       end
     end
 
-    def self.with_after_close(resp, &block)
+    def self.with_after_close(resp, debug_identifier: "unknown", &block)
       # Responses should be arrays but in some situations they aren't
       #   e.g. https://github.com/ruby-grape/grape/issues/1041
-      # The safest approach seems to be to rely on implicit destructuring
-      #   since that is currently what Rack::Lint does.
       # See also https://github.com/rack/rack/issues/1239
-      status, headers, body = resp
 
+      unless resp.respond_to?(:to_ary)
+        if resp.respond_to?(:to_a)
+          log_target.warn("Rack response from \"#{debug_identifier}\" cannot be implicitly converted to an array. This is in violation of "\
+                          "the Rack SPEC and will raise an error in future versions.")
+          resp = resp.to_a
+        else
+          log_target.error("Rack response from \"#{debug_identifier}\" cannot be converted to an array. This is in violation of the Rack SPEC "\
+                          "and may cause problems with Skylight operation.")
+          return resp
+        end
+      end
+
+      status, headers, body = resp
       [status, headers, BodyProxy.new(body, &block)]
     end
 
+    def self.log_target
+      @log_target ||= (Skylight::Core::Fanout.registered.first&.config || Logger.new(STDERR))
+    end
+
     include Util::Logging
 
     # For Util::Logging
@@ -84,7 +98,7 @@ module Skylight::Core
           resp = @app.call(env)
 
           if trace
-            Middleware.with_after_close(resp) { trace.submit }
+            Middleware.with_after_close(resp, debug_identifier: "Rack App: #{@app.class}") { trace.submit }
           else
             resp
           end

data/lib/skylight/core/normalizers/active_job/perform.rb

@@ -4,12 +4,12 @@ module Skylight::Core
       class Perform < Normalizer
         register "perform.active_job"
 
-        DELIVERY_JOB = "ActionMailer::DeliveryJob".freeze
+        DELIVERY_JOB = /\AActionMailer::(Mail)?DeliveryJob\Z/.freeze
         DELAYED_JOB_WRAPPER = "ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper".freeze
 
         def self.normalize_title(job_instance)
           job_instance.class.name.to_s.tap do |str|
-            if str == DELIVERY_JOB
+            if str.match(DELIVERY_JOB)
               mailer_class, mailer_method, * = job_instance.arguments
               return ["#{mailer_class}##{mailer_method}", str]
             end

data/lib/skylight/core/normalizers/grape/endpoint.rb

@@ -25,7 +25,8 @@ module Skylight::Core
           end
 
           def get_namespace(endpoint)
-            ::Grape::Namespace.joined_space(endpoint.namespace_stackable(:namespace))
+            # slice off preceding slash for data continuity
+            ::Grape::Namespace.joined_space_path(endpoint.namespace_stackable(:namespace)).to_s[1..-1]
           end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/inflector"
+
 module Skylight::Core::Normalizers::GraphQL
   # Some AS::N events in GraphQL are not super useful.
   # We are purposefully ignoring the following keys (and you probably shouldn't add them):
@@ -11,25 +13,61 @@ module Skylight::Core::Normalizers::GraphQL
     ANONYMOUS = "[anonymous]".freeze
     CAT = "app.graphql".freeze
 
-    def normalize(_trace, name, _payload)
-      [CAT, name, nil]
+    if defined?(::GraphQL::VERSION) && Gem::Version.new(::GraphQL::VERSION) >= Gem::Version.new("1.10")
+      def self.register_graphql
+        register("#{key}.graphql")
+      end
+    else
+      def self.register_graphql
+        register("graphql.#{key}")
+      end
+    end
+
+    def self.inherited(klass)
+      klass.const_set(
+        :KEY,
+        ActiveSupport::Inflector.underscore(
+          ActiveSupport::Inflector.demodulize(klass.name)
+        ).freeze
+      )
+    end
+
+    def self.key
+      self::KEY
     end
+
+    def normalize(_trace, _name, _payload)
+      [CAT, "graphql.#{key}", nil]
+    end
+
+    private
+
+      def key
+        self.class.key
+      end
+
+      def extract_query_name(query)
+        query&.context&.[](:skylight_endpoint) ||
+          query&.operation_name ||
+          ANONYMOUS
+      end
   end
 
   class Lex < Base
-    register "graphql.lex"
+    register_graphql
   end
 
   class Parse < Base
-    register "graphql.parse"
+    register_graphql
   end
 
   class Validate < Base
-    register "graphql.validate"
+    register_graphql
   end
 
   class ExecuteMultiplex < Base
-    register "graphql.execute_multiplex"
+    register_graphql
+
     def normalize_after(trace, _span, _name, payload)
       # This is in normalize_after because the queries may not have
       # an assigned operation name before they are executed.
@@ -44,7 +82,7 @@ module Skylight::Core::Normalizers::GraphQL
       # 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 << (query.operation_name || ANONYMOUS)
+        names << extract_query_name(query)
         errors << query.static_errors.any?
       end
 
@@ -58,14 +96,14 @@ module Skylight::Core::Normalizers::GraphQL
   end
 
   class AnalyzeQuery < Base
-    register "graphql.analyze_query"
+    register_graphql
   end
 
   class ExecuteQuery < Base
-    register "graphql.execute_query"
+    register_graphql
 
-    def normalize(trace, name, payload)
-      query_name = payload[:query]&.operation_name || ANONYMOUS
+    def normalize(trace, _name, payload)
+      query_name = extract_query_name(payload[:query])
 
       if query_name == ANONYMOUS
         meta = { mute_children: true }
@@ -75,18 +113,18 @@ module Skylight::Core::Normalizers::GraphQL
       # but in the case of a single query, it will be the same value anyway.
       trace.endpoint = "graphql:#{query_name}"
 
-      [CAT, "#{name}: #{query_name}", nil, meta]
+      [CAT, "graphql.#{key}: #{query_name}", nil, meta]
     end
   end
 
   class ExecuteQueryLazy < ExecuteQuery
-    register "graphql.execute_query_lazy"
+    register_graphql
 
-    def normalize(trace, name, payload)
+    def normalize(trace, _name, payload)
       if payload[:query]
         super
       elsif payload[:multiplex]
-        [CAT, "#{name}.multiplex", nil]
+        [CAT, "graphql.#{key}.multiplex", nil]
       end
     end
   end

data/lib/skylight/core/probes/action_controller.rb

@@ -27,6 +27,13 @@ module Skylight::Core
                 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
               end
           end
         end

data/lib/skylight/core/probes/graphql.rb

@@ -3,35 +3,36 @@
 module Skylight::Core
   module Probes
     module GraphQL
+      module Instrumentation
+        def initialize(*, **)
+          super
+
+          return unless defined?(@tracers)
+
+          unless @tracers.include?(::GraphQL::Tracing::ActiveSupportNotificationsTracing)
+            @tracers << ::GraphQL::Tracing::ActiveSupportNotificationsTracing
+          end
+        end
+      end
+
       class Probe
         def install
-          ::GraphQL::Schema.class_eval do
-            alias_method :multiplex_without_sk, :multiplex
-
-            # Schema#execute also delegates to multiplex, so this is the only method
-            # we need to override.
-            def multiplex(*args, &block)
-              sk_add_tracer
-              multiplex_without_sk(*args, &block)
-            end
-
-            def sk_add_tracer
-              Skylight::Core::Config::MUTEX.synchronize do
-                graphql_tracer = ::GraphQL::Tracing::ActiveSupportNotificationsTracing
-                unless tracers.include?(graphql_tracer)
-                  $stdout.puts "[SKYLIGHT::CORE] Adding tracer 'GraphQL::Tracing::ActiveSupportNotificationsTracing' to schema"
-                  tracers << graphql_tracer
-                end
-
-                class << self
-                  # Remove the probe and reset multiplex/execute to original version
-                  # after the tracer has been added
-                  alias_method :multiplex, :multiplex_without_sk
-                end
-              end
-            end
+          tracing_klass_name = "::GraphQL::Tracing::ActiveSupportNotificationsTracing"
+          klasses_to_probe = %w(
+            ::GraphQL::Execution::Multiplex
+            ::GraphQL::Query
+          )
+
+          return unless ([tracing_klass_name] + klasses_to_probe).all?(&method(:safe_constantize))
+
+          klasses_to_probe.each do |klass_name|
+            safe_constantize(klass_name).prepend(Instrumentation)
           end
         end
+
+        def safe_constantize(klass_name)
+          Skylight::Core::Util::Inflector.safe_constantize(klass_name)
+        end
       end
     end
 

data/lib/skylight/core/probes/middleware.rb

@@ -33,7 +33,7 @@ module Skylight::Core
                 spans = Skylight::Core::Fanout.instrument(title: name, category: "#{category}")
                 resp = call_without_sk(*args, &block)
 
-                proxied_response = Skylight::Core::Middleware.with_after_close(resp) do
+                proxied_response = Skylight::Core::Middleware.with_after_close(resp, debug_identifier: "Middleware: #{name}") do
                   Skylight::Core::Fanout.done(spans)
                 end
               rescue Exception => err

data/lib/skylight/core/version.rb

@@ -1,5 +1,5 @@
 module Skylight
   module Core
-    VERSION = "4.2.0".freeze
+    VERSION = "4.3.1".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skylight-core
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.1
 platform: ruby
 authors:
 - Tilde, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 2020-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -269,8 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: The core methods of the Skylight profiler.