skylight-core 4.1.2 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31230fe4577c70e86430a7577519b96ad6b9ea1f15c3f5338f68f3dce99eea4e
-  data.tar.gz: 333e4a3a2482b6904e7c03a4f51155f220ebce8f13e602ceded65345275927af
+  metadata.gz: b967f11a876f41f4337a88fce73301993cf3160f862186b64a7d03a931b5ccb6
+  data.tar.gz: b33c7c1ecbfab7545ea7efdbb691371bc35a0f90ef786c8fb8a60e3db9f7a8a8
 SHA512:
-  metadata.gz: ae7bf4433a8e87b1cfe4ffbebe3830078c187aa0708d381e62e790cbb086509f2b022e849294d85219958370a77e4e7d025298946f97a809ca017be1dda05d14
-  data.tar.gz: 895244e11a0e17bacb76cd85e3c7d6b7d4226cc52f57b1ace4ba6ba440ad49d5573d5ec64afa2c61bfcdfcece813d3bc8eb0c74e07553b430e8fbfddbf17c32d
+  metadata.gz: '0285603cf5bdd82f8cfa8c9e0f3c54569b8e46051ccd16926e14498e024e5b92c9432b150422285625eee6b359aa46c036e483bda9a0cd7cf1dfd94edcc0d530'
+  data.tar.gz: 27fdc7636b44ddaece0b205e425a6546b5ef39ad0671a1719983b8133825940bded7c711abf5631eab83326c79fbd20adb0925c41aa934155670487cc5c4bb7a

data/lib/skylight/core/config.rb

@@ -36,6 +36,7 @@ module Skylight::Core
         # == Instrumenter ==
         "ENABLE_SEGMENTS" => :enable_segments,
         "ENABLE_SIDEKIQ" => :enable_sidekiq,
+        "SINATRA_ROUTE_PREFIXES" => :sinatra_route_prefixes,
 
         # == User config settings ==
         "USER_CONFIG_PATH" => :user_config_path,
@@ -54,6 +55,7 @@ module Skylight::Core
         log_sql_parse_errors:     true,
         enable_segments:          true,
         enable_sidekiq:           false,
+        sinatra_route_prefixes:   false,
         'heroku.dyno_info_path':  "/etc/heroku/dyno"
       }
     end
@@ -411,6 +413,10 @@ module Skylight::Core
       !!get(:enable_sidekiq)
     end
 
+    def sinatra_route_prefixes?
+      !!get(:sinatra_route_prefixes)
+    end
+
     def user_config
       @user_config ||= UserConfig.new(self)
     end

data/lib/skylight/core/instrumentable.rb

@@ -92,18 +92,24 @@ 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
           end
 
+          if instrumenter.poisoned?
+            spawn_shutdown_thread!
+            return yield if block_given?
+            return
+          end
+
           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 +138,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)
@@ -162,6 +194,14 @@ module Skylight
           return unless instrumenter
           instrumenter.config
         end
+
+        # Runs the shutdown procedure in the background.
+        # This should do little more than unsubscribe from all ActiveSupport::Notifications
+        def spawn_shutdown_thread!
+          @shutdown_thread || const_get(:LOCK).synchronize do
+            @shutdown_thread ||= Thread.new { @instrumenter&.shutdown }
+          end
+        end
       end
     end
   end

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
@@ -214,6 +260,14 @@ module Skylight::Core
       trace.broken!
     end
 
+    def poison!
+      @poisoned = true
+    end
+
+    def poisoned?
+      @poisoned
+    end
+
     def done(span, meta = nil)
       return unless (trace = @trace_info.current)
       trace.done(span, meta)
@@ -244,12 +298,16 @@ module Skylight::Core
         native_submit_trace(trace)
         true
       rescue => e
-        warn "failed to submit trace to worker; trace=%s, err=%s", trace.uuid, e
-        t { "BACKTRACE:\n#{e.backtrace.join("\n")}" }
-        false
+        handle_instrumenter_error(trace, e)
       end
     end
 
+    def handle_instrumenter_error(trace, e)
+      warn "failed to submit trace to worker; trace=%s, err=%s", trace.uuid, e
+      t { "BACKTRACE:\n#{e.backtrace.join("\n")}" }
+      false
+    end
+
     def ignore?(trace)
       config.ignored_endpoints.include?(trace.endpoint)
     end
@@ -259,9 +317,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

@@ -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
@@ -78,13 +92,13 @@ 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)
 
           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

@@ -0,0 +1,131 @@
+# 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):
+  #  - "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
+
+    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
+  end
+
+  class Parse < Base
+    register_graphql
+  end
+
+  class Validate < Base
+    register_graphql
+  end
+
+  class ExecuteMultiplex < Base
+    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.
+      # 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 << 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.none?
+                                               :partial
+                                             end
+    end
+  end
+
+  class AnalyzeQuery < Base
+    register_graphql
+  end
+
+  class ExecuteQuery < Base
+    register_graphql
+
+    def normalize(trace, _name, payload)
+      query_name = extract_query_name(payload[:query])
+
+      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, "graphql.#{key}: #{query_name}", nil, meta]
+    end
+  end
+
+  class ExecuteQueryLazy < ExecuteQuery
+    register_graphql
+
+    def normalize(trace, _name, payload)
+      if payload[:query]
+        super
+      elsif payload[:multiplex]
+        [CAT, "graphql.#{key}.multiplex", nil]
+      end
+    end
+  end
+end

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/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/probes/graphql.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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
+          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
+
+    register(:graphql, "GraphQL", "graphql", GraphQL::Probe.new)
+  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/probes/net_http.rb

@@ -8,10 +8,11 @@ module Skylight::Core
         DISABLED_KEY = :__skylight_net_http_disabled
 
         def self.disable
+          state_was = Thread.current[DISABLED_KEY]
           Thread.current[DISABLED_KEY] = true
           yield
         ensure
-          Thread.current[DISABLED_KEY] = false
+          Thread.current[DISABLED_KEY] = state_was
         end
 
         def self.disabled?

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

@@ -36,8 +36,18 @@ module Skylight::Core
               dispatch_without_sk!(*args, &block).tap do
                 Skylight::Core::Fanout.each_trace do |trace|
                   # Set the endpoint name to the route name
-                  route = env["sinatra.route"]
-                  trace.endpoint = route if route
+                  if (route = env["sinatra.route"])
+                    # Include the app's mount point (if available)
+                    script_name = trace.instrumenter.config.sinatra_route_prefixes? && env["SCRIPT_NAME"]
+
+                    trace.endpoint =
+                      if script_name && !script_name.empty?
+                        verb, path = route.split(" ", 2)
+                        "#{verb} [#{script_name}]#{path}"
+                      else
+                        route
+                      end
+                  end
                 end
               end
             end

data/lib/skylight/core/sidekiq.rb

@@ -2,6 +2,11 @@ module Skylight
   module Core
     module Sidekiq
       def self.add_middleware(instrumentable)
+        unless defined?(::Sidekiq)
+          instrumentable.warn "Skylight for Sidekiq is active, but Sidekiq is not defined."
+          return
+        end
+
         ::Sidekiq.configure_server do |sidekiq_config|
           instrumentable.debug "Adding Sidekiq Middleware"
 
@@ -22,7 +27,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.3.0".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.3.0
 platform: ruby
 authors:
 - Tilde, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-27 00:00:00.000000000 Z
+date: 2020-04-14 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
@@ -223,6 +224,7 @@ files:
 - lib/skylight/core/probes/excon/middleware.rb
 - lib/skylight/core/probes/faraday.rb
 - lib/skylight/core/probes/grape.rb
+- lib/skylight/core/probes/graphql.rb
 - lib/skylight/core/probes/httpclient.rb
 - lib/skylight/core/probes/middleware.rb
 - lib/skylight/core/probes/mongo.rb