skylight 4.3.2 → 5.0.1

data/lib/skylight/middleware.rb

@@ -1,4 +1,141 @@
+require "securerandom"
+
 module Skylight
-  class Middleware < Core::Middleware
+  # @api private
+  class Middleware
+    class BodyProxy
+      def initialize(body, &block)
+        @body = body
+        @block = block
+        @closed = false
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        return false if name.to_s !~ /^to_ary$/
+
+        @body.respond_to?(name, include_all)
+      end
+
+      def close
+        return if @closed
+
+        @closed = true
+        begin
+          @body.close if @body.respond_to? :close
+        ensure
+          @block.call
+        end
+      end
+
+      def closed?
+        @closed
+      end
+
+      # N.B. This method is a special case to address the bug described by
+      # https://github.com/rack/rack/issues/434.
+      # We are applying this special case for #each only. Future bugs of this
+      # class will be handled by requesting users to patch their ruby
+      # implementation, to save adding too many methods in this class.
+      def each(*args, &block)
+        @body.each(*args, &block)
+      end
+
+      def method_missing(*args, &block)
+        super if args.first.to_s =~ /^to_ary$/
+        @body.__send__(*args, &block)
+      end
+    end
+
+    def self.with_after_close(resp, debug_identifier: "unknown", &block)
+      unless resp.respond_to?(:to_ary)
+        if resp.respond_to?(:to_a)
+          Skylight.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
+          Skylight.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
+
+    include Skylight::Util::Logging
+
+    # For Util::Logging
+    attr_reader :config
+
+    def initialize(app, opts = {})
+      @app = app
+      @config = opts[:config]
+    end
+
+    def call(env)
+      set_request_id(env)
+
+      if Skylight.tracing?
+        error "Already instrumenting. Make sure the Skylight Rack Middleware hasn't been added more than once."
+      end
+
+      if env["REQUEST_METHOD"] == "HEAD"
+        t { "middleware skipping HEAD" }
+        @app.call(env)
+      else
+        begin
+          t { "middleware beginning trace" }
+          trace = Skylight.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, debug_identifier: "Rack App: #{@app.class}") { trace.submit }
+          else
+            resp
+          end
+        rescue Exception => e
+          t { "middleware exception: #{e}\n#{e.backtrace.join("\n")}" }
+          trace&.submit
+          raise
+        end
+      end
+    end
+
+    private
+
+      def log_context
+        # Don't cache this, it will change
+        { request_id: @current_request_id, inst: Skylight.instrumenter&.uuid }
+      end
+
+      # Allow for overwriting
+      def endpoint_name(_env)
+        "Rack"
+      end
+
+      def endpoint_meta(_env)
+        { source_location: Trace::SYNTHETIC }
+      end
+
+      # Request ID code based on ActionDispatch::RequestId
+      def set_request_id(env)
+        existing_request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+        @current_request_id = env["skylight.request_id"] = make_request_id(existing_request_id)
+      end
+
+      def make_request_id(request_id)
+        if request_id && !request_id.empty?
+          request_id.gsub(/[^\w\-]/, "".freeze)[0...255]
+        else
+          internal_request_id
+        end
+      end
+
+      def internal_request_id
+        SecureRandom.uuid
+      end
   end
 end

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)
@@ -51,7 +101,7 @@ module Skylight
 
   # @api private
   def self.check_install_errors(config)
-    # Note: An unsupported arch doesn't count as an error.
+    # NOTE: An unsupported arch doesn't count as an error.
     install_log = File.expand_path("../../ext/install.log", __dir__)
 
     if File.exist?(install_log) && File.read(install_log) =~ /ERROR/

data/lib/skylight/native_ext_fetcher.rb

@@ -23,7 +23,7 @@ module Skylight
     # @param opts [Hash]
     def self.fetch(**args)
       args[:source] ||= BASE_URL
-      args[:logger] ||= Logger.new(STDOUT)
+      args[:logger] ||= Logger.new($stdout)
       new(**args).fetch
     end
 
@@ -35,7 +35,7 @@ module Skylight
     # @param required [Boolean] whether the download is required to be successful
     # @param platform
     # @param log [Logger]
-    def initialize(source:, target:, version:, checksum:, arch:, required: false, platform: nil, logger:)
+    def initialize(source:, target:, version:, checksum:, arch:, logger:, required: false, platform: nil)
       raise "source required" unless source
       raise "target required" unless target
       raise "checksum required" unless checksum
@@ -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,153 @@
+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.each_value { |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 ||= {}
+        cache_key = ret.hash
+        process_meta(trace, name, payload, meta, cache_key: cache_key)
+
+        [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
+        shrine].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_hint: [: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