skylight 4.3.2 → 5.0.0.beta

data/lib/skylight/native.rb

@@ -1,6 +1,55 @@
 require "skylight/util/platform"
 
 module Skylight
+  # Some methods exepected to be defined by the native code (OUTDATED)
+  #
+  #   * Skylight::Util::Clock#native_hrtime
+  #       - returns current time in nanoseconds
+  #   * Skylight::Trace#native_new(start, uuid, endpoint)
+  #       - start is milliseconds
+  #       - uuid is currently unused
+  #       - endpoint is the endpoint name
+  #       - returns an instance of Trace
+  #   * Skylight::Trace#native_get_started_at
+  #       - returns the start time
+  #   * Skylight::Trace#native_get_endpoint
+  #       - returns the endpoint name
+  #   * Skylight::Trace#native_set_endpoint(endpoint)
+  #       - returns nil
+  #   * Skylight::Trace#native_get_uuid
+  #       - returns the uuid
+  #   * Skylight::Trace#native_start_span(time, category)
+  #       - time is milliseconds
+  #       - category is a string
+  #       - returns a numeric span id
+  #   * Skylight::Trace#native_stop_span(span, time)
+  #       - span is the span id
+  #       - time is milliseconds
+  #       - returns nil
+  #   * Skylight::Trace#native_span_set_title(span, title)
+  #       - span is the span id
+  #       - title is a string
+  #       - returns nil
+  #   * Skylight::Trace#native_span_set_description(span, desc)
+  #       - span is the span id
+  #       - desc is a string
+  #       - returns nil
+  #   * Skylight::Instrumenter#native_new(env)
+  #       - env is the config converted to a flattened array of ENV style values
+  #             e.g. `["SKYLIGHT_AUTHENTICATION", "abc123", ...]
+  #       - returns a new Instrumenter instance
+  #   * Skylight::Instrumenter#native_start()
+  #       - returns a truthy value if successful
+  #   * Skylight::Instrumenter#native_stop()
+  #       - returns nil
+  #   * Skylight::Instrumenter#native_submit_trace(trace)
+  #       - trace is a Trace instance
+  #       - returns nil
+  #   * Skylight::Instrumenter#native_track_desc(endpoint, description)
+  #       - endpoint is a string
+  #       - description is a string
+  #       - returns truthy unless uniqueness cap exceeded
+
   # @api private
   # Whether or not the native extension is present
   @has_native_ext = false
@@ -40,7 +89,8 @@ module Skylight
   end
 
   if Skylight.native?
-    Skylight::Core::Util::Clock.use_native!
+    require "skylight/util/clock"
+    Util::Clock.use_native!
   else
     class Instrumenter
       def self.native_new(*_args)

data/lib/skylight/native_ext_fetcher.rb

@@ -112,7 +112,8 @@ module Skylight
         rescue => e
           remaining_attempts -= 1
 
-          error "failed to fetch native extension; uri=#{uri}; msg=#{e.message}; remaining-attempts=#{remaining_attempts}", e
+          error "failed to fetch native extension; uri=#{uri}; msg=#{e.message}; " \
+                "remaining-attempts=#{remaining_attempts}", e
 
           if remaining_attempts > 0
             sleep 2

data/lib/skylight/normalizers.rb

@@ -0,0 +1,151 @@
+module Skylight
+  # @api private
+  # Convert AS::N events to Skylight events
+  module Normalizers
+    def self.registry
+      @registry ||= {}
+    end
+
+    def self.register(name, klass, opts = {})
+      enabled = opts[:enabled] != false
+      registry[name] = [klass, enabled]
+    end
+
+    def self.unregister(name)
+      @registry.delete(name)
+    end
+
+    def self.enable(*names, enabled: true)
+      names.each do |name|
+        matches = registry.select { |n, _| n =~ /(^|\.)#{name}$/ }
+        raise ArgumentError, "no normalizers match #{name}" if matches.empty?
+
+        matches.values.each { |v| v[1] = enabled }
+      end
+    end
+
+    def self.disable(*names)
+      enable(*names, enabled: false)
+    end
+
+    def self.build(config)
+      normalizers = {}
+
+      registry.each do |key, (klass, enabled)|
+        next unless enabled
+
+        unless klass.method_defined?(:normalize)
+          # TODO: Warn
+          next
+        end
+
+        normalizers[key] = klass.new(config)
+      end
+
+      Container.new(normalizers)
+    end
+
+    class Normalizer
+      def self.register(name, opts = {})
+        Normalizers.register(name, self, opts)
+      end
+
+      attr_reader :config
+
+      include Util::Logging
+
+      def initialize(config)
+        @config = config
+        setup if respond_to?(:setup)
+      end
+
+      def normalize(_trace, _name, _payload)
+        :skip
+      end
+
+      def normalize_with_meta(trace, name, payload)
+        # If we have a normal response but no meta, add it
+        cat, title, desc, meta = ret = normalize(trace, name, payload)
+        return cat if cat == :skip
+
+        meta ||= {}
+        process_meta(trace, name, payload, meta, cache_key: ret.hash)
+
+        [cat, title, desc, meta]
+      end
+
+      def normalize_after(trace, span, name, payload); end
+
+      private
+
+        def process_meta(trace, name, payload, meta, cache_key: nil)
+          trace.instrumenter.extensions.process_normalizer_meta(
+            payload,
+            meta,
+            cache_key: cache_key,
+            **process_meta_options(payload)
+          )
+        end
+
+        def process_meta_options(_payload)
+          {}
+        end
+    end
+
+    require "skylight/normalizers/default"
+    DEFAULT = Default.new
+
+    class Container
+      def initialize(normalizers)
+        @normalizers = normalizers
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def normalize(trace, name, payload)
+        normalizer_for(name).normalize_with_meta(trace, name, payload)
+      end
+
+      def normalize_after(trace, span, name, payload)
+        normalizer_for(name).normalize_after(trace, span, name, payload)
+      end
+
+      def normalizer_for(name)
+        # We never expect to hit the default case since we only register listeners
+        # for items that we know have normalizers. For now, though, we'll play it
+        # safe and provide a fallback.
+        @normalizers.fetch(name, DEFAULT)
+      end
+    end
+
+    %w[ action_controller/process_action
+        action_controller/send_file
+        action_dispatch/process_middleware
+        action_dispatch/route_set
+        action_view/render_collection
+        action_view/render_partial
+        action_view/render_template
+        action_view/render_layout
+        active_job/perform
+        active_model_serializers/render
+        active_record/instantiation
+        active_record/sql
+        active_storage
+        active_support/cache
+        coach/handler_finish
+        coach/middleware_finish
+        couch_potato/query
+        data_mapper/sql
+        elasticsearch/request
+        faraday/request
+        grape/endpoint
+        graphiti/resolve
+        graphiti/render
+        graphql/base
+        sequel/sql].each do |file|
+      require "skylight/normalizers/#{file}"
+    end
+  end
+end

data/lib/skylight/normalizers/action_controller/process_action.rb

@@ -0,0 +1,69 @@
+module Skylight
+  module Normalizers
+    module ActionController
+      # Normalizer for processing a Rails controller action
+      class ProcessAction < Normalizer
+        register "process_action.action_controller"
+
+        CAT = "app.controller.request".freeze
+
+        # Payload Keys: controller, action, params, format, method, path
+        #   Additional keys available in `normalize_after`: status, view_runtime
+        #     Along with ones added by probe: variant
+
+        # @param trace [Skylight::Messages::Trace::Builder]
+        # @param name [String] ignored, only present to match API
+        # @param payload [Hash]
+        # @option payload [String] :controller Controller name
+        # @option payload [String] :action Action name
+        # @return [Array]
+        def normalize(trace, _name, payload)
+          trace.endpoint = controller_action(payload)
+          [CAT, trace.endpoint, nil]
+        end
+
+        def normalize_after(trace, _span, _name, payload)
+          return unless config.enable_segments?
+
+          if (segment = segment_from_payload(payload))
+            trace.segment = segment
+          end
+        end
+
+        private
+
+          def controller_action(payload)
+            "#{payload[:controller]}##{payload[:action]}"
+          end
+
+          def process_meta_options(payload)
+            # provide hints to override default source_location behavior
+            super.merge(source_location: [:instance_method, payload[:controller], payload[:action]])
+          end
+
+          def segment_from_payload(payload)
+            # Show 'error' if there's an unhandled exception or if the status is 4xx or 5xx
+            return "error" if payload[:exception] || payload[:exception_object]
+
+            segment_from_status(payload[:status]) ||
+              if payload[:sk_rendered_format]
+                # We only show the variant if we actually have a format
+                # We won't have a sk_rendered_format if it's a `head` outside of a `respond_to` block.
+                [payload[:sk_rendered_format], payload[:sk_variant]].compact.flatten.join("+")
+              end
+          end
+
+          def segment_from_status(status)
+            case status
+            when 304
+              "not modified"
+            when (300..399)
+              "redirect"
+            when (400..599)
+              "error"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_controller/send_file.rb

@@ -0,0 +1,50 @@
+module Skylight
+  module Normalizers
+    module ActionController
+      enabled = true
+
+      # Temporary hacks
+      begin
+        require "action_dispatch/http/mime_type"
+        require "action_dispatch/http/mime_types"
+        require "rack/utils"
+      rescue LoadError
+        enabled = false
+      end
+
+      if enabled
+        class SendFile < Normalizer
+          register "send_file.action_controller"
+
+          CAT = "app.controller.send_file".freeze
+          TITLE = "send file".freeze
+
+          def normalize(_trace, _name, _payload)
+            title = TITLE
+
+            # depending on normalization, we probably want this to eventually
+            # include the full path, but we need to make sure we have a good
+            # deduping strategy first.
+            desc = nil
+
+            [CAT, title, desc]
+          end
+
+          private
+
+            OCTET_STREAM = "application/octet-stream".freeze
+            ATTACHMENT = "attachment".freeze
+
+            def initialize(*)
+              super
+
+              @mimes = Mime::SET.each_with_object({}) do |mime, hash|
+                hash[mime.symbol] = mime.to_s.dup.freeze
+                hash
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_dispatch/process_middleware.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Normalizers
+    module ActionDispatch
+      class ProcessMiddleware < Normalizer
+        register "process_middleware.action_dispatch"
+
+        CAT = "rack.middleware"
+        ANONYMOUS_MIDDLEWARE = "Anonymous Middleware"
+        ANONYMOUS = /\A#<(Class|Module|Proc):/.freeze
+
+        def normalize(trace, _name, payload)
+          name = payload[:middleware].to_s
+          name = ANONYMOUS_MIDDLEWARE if name[ANONYMOUS]
+          trace.endpoint = name
+          [CAT, name, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_dispatch/route_set.rb

@@ -0,0 +1,27 @@
+module Skylight
+  module Normalizers
+    module ActionDispatch
+      class RouteSet < Normalizer
+        register "route_set.action_dispatch"
+
+        CAT = "rack.app".freeze
+
+        def normalize(trace, _name, _payload)
+          trace.endpoint = router_class_name
+          [CAT, trace.endpoint, nil]
+        end
+
+        private
+
+          def router_class_name
+            "ActionDispatch::Routing::RouteSet"
+          end
+
+          def process_meta_options(_payload)
+            # provide hints to override default source_location behavior
+            super.merge(source_location: [:own_instance_method, router_class_name, "call"])
+          end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_view/render_collection.rb

@@ -0,0 +1,24 @@
+require "skylight/normalizers/render"
+
+module Skylight
+  module Normalizers
+    module ActionView
+      # Normalizer for Rails collection rendering
+      class RenderCollection < RenderNormalizer
+        register "render_collection.action_view"
+
+        CAT = "view.render.collection".freeze
+
+        # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
+        # @param name [String] ignored, only present to match API
+        # @param payload (see RenderNormalizer#normalize_render)
+        # @option payload (see RenderNormalizer#normalize_render)
+        # @option payload [Integer] :count
+        # @return (see RenderNormalizer#normalize_render)
+        def normalize(_trace, _name, payload)
+          normalize_render(CAT, payload)
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_view/render_layout.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "skylight/normalizers/render"
+
+module Skylight
+  module Normalizers
+    module ActionView
+      # Normalizer for Rails layout rendering
+      class RenderLayout < RenderNormalizer
+        register "render_layout.action_view"
+
+        CAT = "view.render.layout"
+
+        # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
+        # @param name [String] ignored, only present to match API
+        # @param payload (see RenderNormalizer#normalize_render)
+        # @option payload (see RenderNormalizer#normalize_render)
+        # @return (see RenderNormalizer#normalize_render)
+        def normalize(_trace, _name, payload)
+          normalize_render(CAT, payload)
+        end
+      end
+    end
+  end
+end