skylight 4.3.2 → 5.1.1

data/lib/skylight/middleware.rb

@@ -1,4 +1,137 @@
+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)
+
+          trace ? Middleware.with_after_close(resp, debug_identifier: "Rack App: #{@app.class}") { trace.submit } : resp
+        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)
+      request_id && !request_id.empty? ? request_id.gsub(/[^\w\-]/, "".freeze)[0...255] : internal_request_id
+    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,24 +101,22 @@ 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/
-      config.alert_logger.error \
-        "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension failed to install. " \
-        "Please check #{install_log} and notify support@skylight.io. " \
-        "The missing extension will not affect the functioning of your application."
+      config.alert_logger.error "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension failed to install. " \
+                                  "Please check #{install_log} and notify support@skylight.io. " \
+                                  "The missing extension will not affect the functioning of your application."
     end
   end
 
   # @api private
   def self.warn_skylight_native_missing(config)
-    config.alert_logger.error \
-      "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for " \
-      "your platform wasn't found. Supported operating systems are " \
-      "Linux 2.6.18+ and Mac OS X 10.8+. The missing extension will not " \
-      "affect the functioning of your application. If you are on a " \
-      "supported platform, please contact support at support@skylight.io."
+    config.alert_logger.error "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for " \
+                                "your platform wasn't found. Supported operating systems are " \
+                                "Linux 2.6.18+ and Mac OS X 10.8+. The missing extension will not " \
+                                "affect the functioning of your application. If you are on a " \
+                                "supported platform, please contact support at support@skylight.io."
   end
 end

data/lib/skylight/native_ext_fetcher.rb

@@ -17,13 +17,14 @@ module Skylight
 
     include FileUtils
 
-    class FetchError < StandardError; end
+    class FetchError < StandardError
+    end
 
     # Creates a new fetcher and fetches
     # @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 +36,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
@@ -56,7 +57,7 @@ module Skylight
     # @return [String] the inflated archive
     def fetch
       log "fetching native ext; curr-platform=#{@platform}; " \
-        "requested-arch=#{@arch}; version=#{@version}"
+            "requested-arch=#{@arch}; version=#{@version}"
 
       tar_gz = "#{@target}/#{basename}"
 
@@ -109,10 +110,12 @@ module Skylight
               next
             end
           end
-        rescue => e
+        rescue StandardError => 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
@@ -148,9 +151,7 @@ module Skylight
       opts = {}
       opts[:use_ssl] = use_ssl
 
-      if use_ssl
-        opts[:ca_file] = Util::SSL.ca_cert_file_or_default
-      end
+      opts[:ca_file] = Util::SSL.ca_cert_file_or_default if use_ssl
 
       Net::HTTP.start(host, port, p_host, p_port, p_user, p_pass, use_ssl: use_ssl) do |http|
         http.request_get path do |resp|
@@ -163,13 +164,13 @@ module Skylight
               out.write chunk
             end
 
-            return [:success, digest.hexdigest]
+            return :success, digest.hexdigest
           when Net::HTTPRedirection
             unless (location = resp["location"])
               raise "received redirect but no location"
             end
 
-            return [:redirect, location]
+            return :redirect, location
           else
             raise "received HTTP status code #{resp.code}"
           end
@@ -220,9 +221,7 @@ module Skylight
     def maybe_raise(err)
       error err
 
-      if @required
-        raise err
-      end
+      raise err if @required
     end
 
     # Log an `info` to the `logger`

data/lib/skylight/normalizers.rb

@@ -0,0 +1,157 @@
+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 each_key(&block)
+        @normalizers.each_key(&block)
+      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 { |file| require "skylight/normalizers/#{file}" }
+  end
+end