skylight-core 4.1.2 → 4.2.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31230fe4577c70e86430a7577519b96ad6b9ea1f15c3f5338f68f3dce99eea4e
-  data.tar.gz: 333e4a3a2482b6904e7c03a4f51155f220ebce8f13e602ceded65345275927af
+  metadata.gz: 7836c1098f49c2f7b0f8581656367354e1ccec3c148f593a96df4deef011e9c9
+  data.tar.gz: 390b30be3374c7bcb827806c230d36772a96bef0f5692c83a2730d4face3f162
 SHA512:
-  metadata.gz: ae7bf4433a8e87b1cfe4ffbebe3830078c187aa0708d381e62e790cbb086509f2b022e849294d85219958370a77e4e7d025298946f97a809ca017be1dda05d14
-  data.tar.gz: 895244e11a0e17bacb76cd85e3c7d6b7d4226cc52f57b1ace4ba6ba440ad49d5573d5ec64afa2c61bfcdfcece813d3bc8eb0c74e07553b430e8fbfddbf17c32d
+  metadata.gz: ab419f49f172e95c075796d849ad643eb84032a98fe392b38101d93a3c6a7c2477d381f224752b0ae20ad607a7f883fdcbda4485f34f03e2ffaace66a8c1e18b
+  data.tar.gz: f1db03e7f479a3853036f6c7d3f94b7081cd5545cf4286d83393f8b19ff4e350f29cd91a869d93f0cb505d8a22dd4439165f477c27290aa5ce14b13649dc34f0

data/lib/skylight/core/instrumentable.rb

@@ -92,7 +92,7 @@ module Skylight
         end
 
         # Start a trace
-        def trace(endpoint = nil, cat = nil, title = nil, meta: nil, segment: nil)
+        def trace(endpoint = nil, cat = nil, title = nil, meta: nil, segment: nil, component: nil)
           unless instrumenter
             return yield if block_given?
             return
@@ -101,9 +101,9 @@ module Skylight
           cat ||= DEFAULT_CATEGORY
 
           if block_given?
-            instrumenter.trace(endpoint, cat, title, nil, meta: meta, segment: segment) { |tr| yield tr }
+            instrumenter.trace(endpoint, cat, title, nil, meta: meta, segment: segment, component: component) { |tr| yield tr }
           else
-            instrumenter.trace(endpoint, cat, title, nil, meta: meta, segment: segment)
+            instrumenter.trace(endpoint, cat, title, nil, meta: meta, segment: segment, component: component)
           end
         end
 
@@ -132,6 +132,32 @@ module Skylight
           instrumenter.instrument(category, title, desc, meta, &block)
         end
 
+        def mute
+          unless instrumenter
+            return yield if block_given?
+            return
+          end
+
+          instrumenter.mute do
+            yield if block_given?
+          end
+        end
+
+        def unmute
+          unless instrumenter
+            return yield if block_given?
+            return
+          end
+
+          instrumenter.unmute do
+            yield if block_given?
+          end
+        end
+
+        def muted?
+          instrumenter&.muted?
+        end
+
         def span_correlation_header(span)
           return unless instrumenter
           instrumenter.span_correlation_header(span)

data/lib/skylight/core/instrumenter.rb

@@ -13,6 +13,7 @@ module Skylight::Core
     class TraceInfo
       def initialize(key = KEY)
         @key = key
+        @muted_key = "#{key}_muted"
       end
 
       def current
@@ -22,9 +23,20 @@ module Skylight::Core
       def current=(trace)
         Thread.current[@key] = trace
       end
+
+      # NOTE: This should only be set by the instrumenter, and only
+      # in the context of a `mute` block. Do not try to turn this
+      # flag on and off directly.
+      def muted=(val)
+        Thread.current[@muted_key] = val
+      end
+
+      def muted?
+        !!Thread.current[@muted_key]
+      end
     end
 
-    attr_reader :uuid, :config, :gc, :trace_info
+    attr_reader :uuid, :config, :gc
 
     def self.trace_class
       Trace
@@ -51,6 +63,7 @@ module Skylight::Core
 
       key = "#{KEY}_#{self.class.trace_class.name}".gsub(/\W/, "_")
       @trace_info = @config[:trace_info] || TraceInfo.new(key)
+      @mutex = Mutex.new
     end
 
     def log_context
@@ -86,6 +99,45 @@ module Skylight::Core
       true
     end
 
+    def muted=(val)
+      @trace_info.muted = val
+    end
+
+    def muted?
+      @trace_info.muted?
+    end
+
+    def mute
+      old_muted = muted?
+      self.muted = true
+      yield if block_given?
+    ensure
+      self.muted = old_muted
+    end
+
+    def unmute
+      old_muted = muted?
+      self.muted = false
+      yield if block_given?
+    ensure
+      self.muted = old_muted
+    end
+
+    def silence_warnings(context)
+      @warnings_silenced || @mutex.synchronize do
+        @warnings_silenced ||= {}
+      end
+
+      @warnings_silenced[context] = true
+    end
+
+    def warnings_silenced?(context)
+      @warnings_silenced && @warnings_silenced[context]
+    end
+
+    alias_method :disable, :mute
+    alias_method :disabled?, :muted?
+
     def start!
       # We do this here since we can't report these issues via Gem install without stopping install entirely.
       check_install!
@@ -120,7 +172,7 @@ module Skylight::Core
       native_stop
     end
 
-    def trace(endpoint, cat, title = nil, desc = nil, meta: nil, segment: nil)
+    def trace(endpoint, cat, title = nil, desc = nil, meta: nil, segment: nil, component: nil)
       # If a trace is already in progress, continue with that one
       if (trace = @trace_info.current)
         return yield(trace) if block_given?
@@ -128,7 +180,7 @@ module Skylight::Core
       end
 
       begin
-        trace = self.class.trace_class.new(self, endpoint, Util::Clock.nanos, cat, title, desc, meta: meta, segment: segment)
+        trace = self.class.trace_class.new(self, endpoint, Util::Clock.nanos, cat, title, desc, meta: meta, segment: segment, component: component)
       rescue Exception => e
         log_error e.message
         t { e.backtrace.join("\n") }
@@ -147,17 +199,6 @@ module Skylight::Core
       end
     end
 
-    def disable
-      @disabled = true
-      yield
-    ensure
-      @disabled = false
-    end
-
-    def disabled?
-      defined?(@disabled) && @disabled
-    end
-
     def self.match?(string, regex)
       @scanner ||= StringScanner.new("")
       @scanner.string = string
@@ -171,6 +212,11 @@ module Skylight::Core
     def instrument(cat, title = nil, desc = nil, meta = nil)
       raise ArgumentError, "cat is required" unless cat
 
+      if muted?
+        return yield if block_given?
+        return
+      end
+
       unless (trace = @trace_info.current)
         return yield if block_given?
         return
@@ -259,9 +305,29 @@ module Skylight::Core
       [nil, sql]
     end
 
+    # Because GraphQL can return multiple results, each of which
+    # may have their own success/error states, we need to set the
+    # skylight segment as follows:
+    #
+    # - when all queries have errors: "error"
+    # - when some queries have errors: "<rendered format>+error"
+    # - when no queries have errors: "<rendered format>"
+    #
+    # <rendered format> will be determined by the Rails controller as usual.
+    # See Instrumenter#finalize_endpoint_segment for the actual segment/error assignment.
     def finalize_endpoint_segment(trace)
-      return unless trace.segment
-      trace.endpoint += "<sk-segment>#{trace.segment}</sk-segment>"
+      return unless (segment = trace.segment)
+
+      segment = case trace.compound_response_error_status
+                when :all
+                  "error"
+                when :partial
+                  "#{segment}+error"
+                else
+                  segment
+                end
+
+      trace.endpoint += "<sk-segment>#{segment}</sk-segment>"
     end
   end
 end

data/lib/skylight/core/middleware.rb

@@ -78,7 +78,7 @@ module Skylight::Core
       else
         begin
           t { "middleware beginning trace" }
-          trace = instrumentable.trace(endpoint_name(env), "app.rack.request", nil, meta: endpoint_meta(env))
+          trace = instrumentable.trace(endpoint_name(env), "app.rack.request", nil, meta: endpoint_meta(env), component: :web)
           t { "middleware began trace=#{trace ? trace.uuid : nil}" }
 
           resp = @app.call(env)

data/lib/skylight/core/normalizers.rb

@@ -113,6 +113,7 @@ module Skylight::Core
         grape/endpoint
         graphiti/resolve
         graphiti/render
+        graphql/base
         moped/query
         sequel/sql].each do |file|
       require "skylight/core/normalizers/#{file}"

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+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):
+  #  - "graphql.analyze_multiplex"
+  #  - "graphql.execute_field" (very frequently called)
+  #  - "graphql.execute_field_lazy"
+
+  class Base < Skylight::Core::Normalizers::Normalizer
+    ANONYMOUS = "[anonymous]".freeze
+    CAT = "app.graphql".freeze
+
+    def normalize(_trace, name, _payload)
+      [CAT, name, nil]
+    end
+  end
+
+  class Lex < Base
+    register "graphql.lex"
+  end
+
+  class Parse < Base
+    register "graphql.parse"
+  end
+
+  class Validate < Base
+    register "graphql.validate"
+  end
+
+  class ExecuteMultiplex < Base
+    register "graphql.execute_multiplex"
+    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.
+      # For example, if you send a single query with a defined operation name, e.g.:
+      # ```graphql
+      #   query MyNamedQuery { user(id: 1) { name } }
+      # ```
+      # ... but do _not_ send the operationName request param, the GraphQL docs[1]
+      # specify that the executor should use the operation name from the definition.
+      #
+      # 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 << (query.operation_name || ANONYMOUS)
+        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.none?
+                                               :partial
+                                             end
+    end
+  end
+
+  class AnalyzeQuery < Base
+    register "graphql.analyze_query"
+  end
+
+  class ExecuteQuery < Base
+    register "graphql.execute_query"
+
+    def normalize(trace, name, payload)
+      query_name = payload[:query]&.operation_name || ANONYMOUS
+
+      if query_name == ANONYMOUS
+        meta = { mute_children: true }
+      end
+
+      # 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.
+      trace.endpoint = "graphql:#{query_name}"
+
+      [CAT, "#{name}: #{query_name}", nil, meta]
+    end
+  end
+
+  class ExecuteQueryLazy < ExecuteQuery
+    register "graphql.execute_query_lazy"
+
+    def normalize(trace, name, payload)
+      if payload[:query]
+        super
+      elsif payload[:multiplex]
+        [CAT, "#{name}.multiplex", nil]
+      end
+    end
+  end
+end

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

@@ -9,19 +9,24 @@ module Skylight::Core
               def append_info_to_payload(payload)
                 append_info_to_payload_without_sk(payload)
 
-                rendered_mime = begin
-                  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
+                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
 
-                payload[:sk_rendered_format] = rendered_mime.try(:ref)
-                payload[:sk_variant] = request.respond_to?(:variant) ? request.variant : 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
               end
           end
         end

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

@@ -9,7 +9,7 @@ module Skylight::Core
             alias execute_without_sk execute
 
             def execute(*args)
-              Skylight.trace(TITLE, "app.job.execute") do |trace|
+              Skylight.trace(TITLE, "app.job.execute", component: :worker) do |trace|
                 # See normalizers/active_job/perform for endpoint/segment assignment
                 begin
                   execute_without_sk(*args)

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

@@ -24,7 +24,7 @@ module Skylight::Core
                 UNKNOWN
               end
 
-              Skylight.trace(handler_name, "app.delayed_job.worker", "Delayed::Worker#run", segment: job.queue) do
+              Skylight.trace(handler_name, "app.delayed_job.worker", "Delayed::Worker#run", component: :worker, segment: job.queue) do
                 run_without_sk(job, *args)
               end
             end

data/lib/skylight/core/sidekiq.rb

@@ -22,7 +22,7 @@ module Skylight
         def call(_worker, job, queue)
           t { "Sidekiq middleware beginning trace" }
           title = job["wrapped"] || job["class"]
-          @instrumentable.trace(title, "app.sidekiq.worker", title, segment: queue) do |trace|
+          @instrumentable.trace(title, "app.sidekiq.worker", title, segment: queue, component: :worker) do |trace|
             begin
               yield
             rescue Exception # includes Sidekiq::Shutdown

data/lib/skylight/core/subscriber.rb

@@ -50,14 +50,12 @@ module Skylight::Core
 
       while (curr = trace.notifications.pop)
         next unless curr.name == name
-        begin
-          normalize_after(trace, curr.span, name, payload)
-        ensure
-          meta = {}
-          meta[:exception] = payload[:exception] if payload[:exception]
-          meta[:exception_object] = payload[:exception_object] if payload[:exception_object]
-          trace.done(curr.span, meta) if curr.span
-        end
+
+        meta = {}
+        meta[:exception] = payload[:exception] if payload[:exception]
+        meta[:exception_object] = payload[:exception_object] if payload[:exception_object]
+        trace.done(curr.span, meta) if curr.span
+        normalize_after(trace, curr.span, name, payload)
         return
       end
     rescue Exception => e

data/lib/skylight/core/trace.rb

@@ -6,14 +6,14 @@ module Skylight::Core
 
     include Util::Logging
 
-    attr_reader :instrumenter, :endpoint, :notifications, :meta
-    attr_accessor :uuid, :segment
+    attr_reader :instrumenter, :endpoint, :segment, :notifications, :meta
+    attr_accessor :uuid
 
-    def self.new(instrumenter, endpoint, start, cat, title = nil, desc = nil, meta: nil, segment: nil)
+    def self.new(instrumenter, endpoint, start, cat, title = nil, desc = nil, meta: nil, segment: nil, component: nil)
       uuid = SecureRandom.uuid
       inst = native_new(normalize_time(start), uuid, endpoint, meta)
       inst.uuid = uuid
-      inst.send(:initialize, instrumenter, cat, title, desc, meta)
+      inst.send(:initialize, instrumenter, cat, title, desc, meta, component: component)
       inst.endpoint = endpoint
       inst.segment = segment
       inst
@@ -26,7 +26,7 @@ module Skylight::Core
       (time.to_i / 100_000).to_i
     end
 
-    def initialize(instrumenter, cat, title, desc, meta)
+    def initialize(instrumenter, cat, title, desc, meta, **)
       raise ArgumentError, "instrumenter is required" unless instrumenter
 
       @instrumenter = instrumenter
@@ -51,14 +51,32 @@ module Skylight::Core
     end
 
     def endpoint=(value)
+      if muted?
+        maybe_warn(:endpoint_set_muted, "tried to set endpoint name while muted")
+        return
+      end
       @endpoint = value
       native_set_endpoint(value)
     end
 
+    def segment=(value)
+      if muted?
+        maybe_warn(:segment_set_muted, "tried to set segment name while muted")
+        return
+      end
+      @segment = value
+    end
+
+    attr_accessor :compound_response_error_status
+
     def config
       @instrumenter.config
     end
 
+    def muted?
+      !!@child_instrumentation_muted_by || @instrumenter.muted?
+    end
+
     def broken?
       !!@broken
     end
@@ -69,7 +87,7 @@ module Skylight::Core
     end
 
     def record(cat, title = nil, desc = nil)
-      return if broken?
+      return if muted? || broken?
 
       title.freeze if title.is_a?(String)
       desc.freeze  if desc.is_a?(String)
@@ -87,6 +105,7 @@ module Skylight::Core
     end
 
     def instrument(cat, title = nil, desc = nil, meta = nil)
+      return if muted?
       return if broken?
       t { "instrument: #{cat}, #{title}" }
 
@@ -119,10 +138,9 @@ module Skylight::Core
       # `span` will be `nil` if we failed to start instrumenting, such as in
       # the case of too many spans in a request.
       return unless span
-
       return if broken?
 
-      if meta && meta[:defer]
+      if meta&.[](:defer)
         deferred_spans[span] ||= (Util::Clock.nanos - gc_time)
         return
       end
@@ -199,6 +217,8 @@ module Skylight::Core
       def start(time, cat, title, desc, meta, opts = {})
         time = self.class.normalize_time(time) unless opts[:normalize] == false
 
+        mute_children = meta&.delete(:mute_children)
+
         sp = native_start_span(time, cat.to_s)
         native_span_set_title(sp, title.to_s) if title
         native_span_set_description(sp, desc.to_s) if desc
@@ -208,9 +228,18 @@ module Skylight::Core
         @spans << sp
         t { "started span: #{sp} - #{cat}, #{title}" }
 
+        if mute_children
+          t { "muting child instrumentation for span=#{sp}" }
+          mute_child_instrumentation(sp)
+        end
+
         sp
       end
 
+      def mute_child_instrumentation(span)
+        @child_instrumentation_muted_by = span
+      end
+
       # Middleware spans that were interrupted by a throw/catch should be cached here.
       # keys: span ids
       # values: nsec timestamp at which the span was cached here.
@@ -237,6 +266,10 @@ module Skylight::Core
       def normalized_stop(span, time)
         time = self.class.normalize_time(time)
         native_stop_span(span, time)
+
+        if @child_instrumentation_muted_by == span
+          @child_instrumentation_muted_by = nil # restart instrumenting
+        end
       end
 
       # Originally extracted from `stop`.
@@ -271,5 +304,16 @@ module Skylight::Core
         @gc.update
         @gc.time
       end
+
+      def maybe_warn(context, msg)
+        return if warnings_silenced?(context)
+        instrumenter.silence_warnings(context)
+
+        warn(msg)
+      end
+
+      def warnings_silenced?(context)
+        instrumenter.warnings_silenced?(context)
+      end
   end
 end

data/lib/skylight/core/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skylight-core
 version: !ruby/object:Gem::Version
-  version: 4.1.2
+  version: 4.2.0.beta
 platform: ruby
 authors:
 - Tilde, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-27 00:00:00.000000000 Z
+date: 2019-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -204,6 +204,7 @@ files:
 - lib/skylight/core/normalizers/grape/format_response.rb
 - lib/skylight/core/normalizers/graphiti/render.rb
 - lib/skylight/core/normalizers/graphiti/resolve.rb
+- lib/skylight/core/normalizers/graphql/base.rb
 - lib/skylight/core/normalizers/moped/query.rb
 - lib/skylight/core/normalizers/render.rb
 - lib/skylight/core/normalizers/sequel/sql.rb
@@ -263,9 +264,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: