skylight 4.2.3 → 5.3.0

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/action_controller/process_action.rb

@@ -0,0 +1,68 @@
+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

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

@@ -0,0 +1,51 @@
+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_hint: [: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

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

@@ -0,0 +1,23 @@
+require "skylight/normalizers/render"
+
+module Skylight
+  module Normalizers
+    module ActionView
+      # Normalizer for Rails partial rendering
+      class RenderPartial < RenderNormalizer
+        register "render_partial.action_view"
+
+        CAT = "view.render.template".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)
+        # @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_template.rb

@@ -0,0 +1,23 @@
+require "skylight/normalizers/render"
+
+module Skylight
+  module Normalizers
+    module ActionView
+      # Normalizer for Rails template rendering
+      class RenderTemplate < RenderNormalizer
+        register "render_template.action_view"
+
+        CAT = "view.render.template".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)
+        # @return (see RenderNormalizer#normalize_render)
+        def normalize(_trace, _name, payload)
+          normalize_render(CAT, payload)
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_job/perform.rb

@@ -0,0 +1,87 @@
+module Skylight
+  module Normalizers
+    module ActiveJob
+      class Perform < Normalizer
+        register "perform.active_job"
+
+        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.match(DELIVERY_JOB)
+                mailer_class, mailer_method, * = job_instance.arguments
+                return "#{mailer_class}##{mailer_method}", str if mailer_class && mailer_method
+              end
+            end
+        end
+
+        CAT = "app.job.perform".freeze
+
+        def normalize(trace, _name, payload)
+          title = payload[:job].class.to_s
+          adapter_name = normalize_adapter_name(payload[:adapter])
+          desc = "{ adapter: '#{adapter_name}', queue: '#{payload[:job].queue_name}' }"
+
+          maybe_set_endpoint(trace, payload)
+
+          [CAT, title, desc]
+        end
+
+        def normalize_after(trace, _span, _name, payload)
+          maybe_set_endpoint(trace, payload)
+        end
+
+        private
+
+        def process_meta_options(payload)
+          # provide hints to override default source_location behavior
+          super.merge(source_location_hint: [:instance_method, payload[:job].class.to_s, "perform"])
+        end
+
+        def normalize_adapter_name(adapter)
+          adapter_string = adapter.is_a?(Class) ? adapter.to_s : adapter.class.to_s
+          adapter_string[/ActiveJob::QueueAdapters::(\w+)Adapter/, 1].underscore
+        rescue StandardError
+          "active_job"
+        end
+
+        def maybe_set_endpoint(trace, payload)
+          endpoint = normalize_title(payload[:job])
+
+          # Always assign the endpoint if it has not yet been assigned by the ActiveJob probe.
+          if !trace.endpoint ||
+               (defined?(Skylight::Probes::ActiveJob::TITLE) && trace.endpoint == Skylight::Probes::ActiveJob::TITLE) ||
+               (
+                 defined?(Skylight::Probes::DelayedJob::Probe::UNKNOWN) &&
+                   trace.endpoint == Skylight::Probes::DelayedJob::Probe::UNKNOWN
+               ) ||
+               # If a job is called using #perform_now inside a controller action
+               # or within another job's #perform method, we do not want this to
+               # overwrite the existing endpoint name (unless it is the default from ActiveJob).
+               #
+               # If the current endpoint name matches this payload, return true to allow the
+               # segment to be assigned by normalize_after.
+               trace.endpoint =~ DELIVERY_JOB ||
+               # This adapter wrapper needs to be handled specifically due to interactions with the
+               # standalone Delayed::Job probe, as there is no consistent way to get the wrapped
+               # job name among all Delayed::Job backends.
+               trace.endpoint == DELAYED_JOB_WRAPPER
+            trace.endpoint = endpoint
+          end
+
+          trace.segment = payload[:job].queue_name if trace.endpoint == endpoint && config.enable_segments?
+        end
+
+        def normalize_title(job_instance)
+          title, * = self.class.normalize_title(job_instance)
+          title
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_model_serializers/render.rb

@@ -0,0 +1,32 @@
+module Skylight
+  module Normalizers
+    module ActiveModelSerializers
+      class Render < Normalizer
+        register "render.active_model_serializers"
+
+        CAT = "view.render.active_model_serializers".freeze
+        ANONYMOUS = "<Anonymous Serializer>".freeze
+
+        def normalize(_trace, _name, payload)
+          serializer_class = payload[:serializer]
+
+          title = serializer_class.name || ANONYMOUS
+          title = title.sub(/^ActiveModel::(Serializer::)?/, "")
+
+          if (adapter_instance = payload[:adapter])
+            adapter_name =
+              adapter_instance
+                .class
+                .name
+                .to_s
+                .sub(/^ActiveModel::Serializer::Adapter::/, "")
+                .sub(/^ActiveModelSerializers::Adapter::/, "")
+            desc = "Adapter: #{adapter_name}"
+          end
+
+          [CAT, title, desc]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_record/instantiation.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveRecord
+      class Instantiation < Normalizer
+        register "instantiation.active_record"
+
+        CAT = "db.active_record.instantiation".freeze
+
+        def normalize(_trace, _name, payload)
+          # Payload also includes `:record_count` but this will be variable
+          [CAT, "#{payload[:class_name]} Instantiation", nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_record/sql.rb

@@ -0,0 +1,20 @@
+require "skylight/normalizers/sql"
+
+module Skylight
+  module Normalizers
+    module ActiveRecord
+      # Normalizer for SQL requests
+      class SQL < Skylight::Normalizers::SQL
+        register "sql.active_record"
+      end
+
+      class FutureResult < Normalizer
+        register "future_result.active_record"
+
+        def normalize(_trace, _name, payload)
+          ["db.future_result", "Async #{payload[:args][1] || "Query"}"]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_storage.rb

@@ -0,0 +1,28 @@
+module Skylight
+  module Normalizers
+    class ActiveStorage < Normalizer
+      TITLES = {
+        "preview.active_storage" => "Preview",
+        "transform.active_storage" => "Transform",
+        "service_download.active_storage" => "Download",
+        "service_upload.active_storage" => "Upload",
+        "service_streaming_download.active_storage" => "Streaming Download",
+        "service_download_chunk.active_storage" => "Download Chunk",
+        "service_delete.active_storage" => "Delete",
+        "service_delete_prefixed.active_storage" => "Delete Prefixed",
+        "service_exist.active_storage" => "Exist",
+        "service_url.active_storage" => "Url"
+      }.freeze
+
+      TITLES.each_key { |key| register key }
+
+      def normalize(_trace, name, _payload)
+        title = ["ActiveStorage", TITLES[name]].join(" ")
+
+        cat = "app.#{name.split(".").reverse.join(".")}"
+
+        [cat, title, nil]
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache.rb

@@ -0,0 +1,11 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class Cache < Normalizer
+        %w[clear decrement delete exist fetch_hit generate increment read read_multi write].each do |type|
+          require "skylight/normalizers/active_support/cache_#{type}"
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_clear.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheClear < Cache
+        register "cache_clear.active_support"
+
+        CAT = "app.cache.clear".freeze
+        TITLE = "cache clear".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end